Duplicate from lilacai/nikhil_staging

.dockerignore

@@ -0,0 +1,10 @@
+# Python
+**/__pycache__
+**/*.pyc
+**/*.pyo
+**/*.pyd
+# Ignore unit tests.
+**/*_test.py
+
+# Mac OS.
+.DS_Store

.env

@@ -0,0 +1,40 @@
+# To overwrite these variables, create a .env.local file
+
+# The path to the directory where the data will be downloaded on machine
+LILAC_DATA_PATH=./data
+
+# Set to 1 for duckdb to use views instead of materialized tables (lower memory usage, but slower).
+DUCKDB_USE_VIEWS=0
+
+# Set to true to enable read-only mode, disabling the ability to add datasets & compute dataset
+# signals.
+# LILAC_AUTH_ENABLED=true
+
+# Variables that can be set in .env.local
+#
+# Get key from https://dashboard.cohere.ai/api-keys
+# COHERE_API_KEY=
+
+# GCS_REGION=
+# GCS_ACCESS_KEY=
+# GCS_SECRET_KEY=
+
+# Get key from https://platform.openai.com/account/api-keys
+# OPENAI_API_KEY=
+# Get key from https://makersuite.google.com/app/apikey
+# PALM_API_KEY=
+
+# HuggingFace demos: machine that uploads to HuggingFace.
+
+# For authenticating with HuggingFace to deploy to a Space.
+# HF_USERNAME=
+# The default repo to deploy to for a staging demo. Can be overridden by a command line flag.
+# HF_STAGING_DEMO_REPO='HF_ORG/HF_REPO_NAME'
+
+# For Google-login. This is generated from the Google Cloud Console for a web client.
+# See: https://developers.google.com/identity/protocols/oauth2
+GOOGLE_CLIENT_ID='279475920249-i8llm8vbos1vj5m1qocir8narb3r0enu.apps.googleusercontent.com'
+# The client secret of the above client.
+# GOOGLE_CLIENT_SECRET=
+# A random string for oauth sessions.
+# LILAC_OAUTH_SECRET_KEY=

.env.demo

@@ -0,0 +1,4 @@
+LILAC_DATA_PATH='/data'
+HF_HOME=/data/.huggingface
+TRANSFORMERS_CACHE=/data/.cache
+XDG_CACHE_HOME=/data/.cache

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+**/*.pyc
+**/*.pyo
+**/*.pyd
+**/*_test.py

Dockerfile

@@ -0,0 +1,27 @@
+# NOTE: When we upgrade to 3.11 we can use a slimmer docker image which comes with gcc.
+FROM python:3.9-bullseye
+
+# Allow statements and log messages to immediately appear in the Knative logs
+ENV PYTHONUNBUFFERED True
+
+# Set the working directory in the container.
+WORKDIR /server
+
+# Install the dependencies. This requires exporting requirements.txt from poetry first, which
+# happens from ./build_docker.sh.
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY .env .
+COPY .env.demo .
+COPY demo_config.yml .
+# Copy the README so we can read the datasets from the HuggingFace config.
+COPY README.md .
+COPY LICENSE .
+
+# Copy python files.
+COPY /lilac ./lilac/
+
+COPY docker_start.sh docker_start.py ./
+
+CMD ["bash", "docker_start.sh"]

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2023 Lilac AI Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,12 @@
+---
+app_port: 5432
+colorFrom: purple
+colorTo: purple
+datasets:
+- lilacai/nikhil_staging-local-glue
+- lilacai/nikhil_staging-local-imdb
+emoji: 🌷
+sdk: docker
+title: Lilac
+duplicated_from: lilacai/nikhil_staging
+---

demo_config.yml

@@ -0,0 +1,3 @@
+lilac_hf_datasets:
+- {hf_dataset_repo_id: lilacai/nikhil_staging-local-glue, lilac_name: glue, lilac_namespace: local}
+- {hf_dataset_repo_id: lilacai/nikhil_staging-local-imdb, lilac_name: imdb, lilac_namespace: local}

docker_start.py

@@ -0,0 +1,111 @@
+"""Startup work before running the web server."""
+
+import os
+import shutil
+from typing import TypedDict
+
+import yaml
+from huggingface_hub import scan_cache_dir, snapshot_download
+
+from lilac.concepts.db_concept import CONCEPTS_DIR, DiskConceptDB, get_concept_output_dir
+from lilac.env import data_path, env
+from lilac.utils import get_datasets_dir, get_lilac_cache_dir, log
+
+
+def delete_old_files() -> None:
+  """Delete old files from the cache."""
+  # Scan cache
+  try:
+    scan = scan_cache_dir()
+  except BaseException:
+    # Cache was not found.
+    return
+
+  # Select revisions to delete
+  to_delete = []
+  for repo in scan.repos:
+    latest_revision = max(repo.revisions, key=lambda x: x.last_modified)
+    to_delete.extend(
+      [revision.commit_hash for revision in repo.revisions if revision != latest_revision])
+  strategy = scan.delete_revisions(*to_delete)
+
+  # Delete them
+  log(f'Will delete {len(to_delete)} old revisions and save {strategy.expected_freed_size_str}')
+  strategy.execute()
+
+
+class HfSpaceConfig(TypedDict):
+  """The huggingface space config, defined in README.md.
+
+  See:
+  https://huggingface.co/docs/hub/spaces-config-reference
+  """
+  title: str
+  datasets: list[str]
+
+
+def main() -> None:
+  """Download dataset files from the HF space that was uploaded before building the image."""
+  # SPACE_ID is the HuggingFace Space ID environment variable that is automatically set by HF.
+  repo_id = env('SPACE_ID', None)
+  if not repo_id:
+    return
+
+  delete_old_files()
+
+  print('readme:', os.path.abspath('README.md'))
+  with open(os.path.abspath('README.md')) as f:
+    print(f.read())
+
+  with open(os.path.abspath('README.md')) as f:
+    # Strip the '---' for the huggingface readme config.
+    readme = f.read().strip('---')
+    hf_config: HfSpaceConfig = yaml.safe_load(readme)
+
+  # Download the huggingface space data. This includes code and datasets, so we move the datasets
+  # alone to the data directory.
+  for lilac_hf_dataset in hf_config['datasets']:
+    print('Downloading dataset from HuggingFace: ', lilac_hf_dataset)
+    snapshot_download(
+      repo_id=lilac_hf_dataset,
+      repo_type='dataset',
+      token=env('HF_ACCESS_TOKEN'),
+      local_dir=get_datasets_dir(data_path()),
+      ignore_patterns=['.gitattributes', 'README.md'])
+
+  snapshot_dir = snapshot_download(repo_id=repo_id, repo_type='space', token=env('HF_ACCESS_TOKEN'))
+  # # Copy datasets.
+  spaces_data_dir = os.path.join(snapshot_dir, 'data')
+
+  # Delete cache files from persistent storage.
+  cache_dir = get_lilac_cache_dir(data_path())
+  if os.path.exists(cache_dir):
+    shutil.rmtree(cache_dir)
+
+  # NOTE: This is temporary during the move of concepts into the pip package. Once all the demos
+  # have been updated, this block can be deleted.
+  old_lilac_concepts_data_dir = os.path.join(data_path(), CONCEPTS_DIR, 'lilac')
+  if os.path.exists(old_lilac_concepts_data_dir):
+    shutil.rmtree(old_lilac_concepts_data_dir)
+
+  # Copy cache files from the space if they exist.
+  spaces_cache_dir = get_lilac_cache_dir(spaces_data_dir)
+  if os.path.exists(spaces_cache_dir):
+    shutil.copytree(spaces_cache_dir, cache_dir)
+
+  # Copy concepts.
+  concepts = DiskConceptDB(spaces_data_dir).list()
+  for concept in concepts:
+    # Ignore lilac concepts, they're already part of the source code.
+    if concept.namespace == 'lilac':
+      continue
+    spaces_concept_output_dir = get_concept_output_dir(spaces_data_dir, concept.namespace,
+                                                       concept.name)
+    persistent_output_dir = get_concept_output_dir(data_path(), concept.namespace, concept.name)
+    shutil.rmtree(persistent_output_dir, ignore_errors=True)
+    shutil.copytree(spaces_concept_output_dir, persistent_output_dir, dirs_exist_ok=True)
+    shutil.rmtree(spaces_concept_output_dir, ignore_errors=True)
+
+
+if __name__ == '__main__':
+  main()

docker_start.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+# Fail if any of the commands below fail.
+set -e
+
+python docker_start.py
+gunicorn lilac.server:app \
+  --bind 0.0.0.0:5432 \
+  --preload -k uvicorn.workers.UvicornWorker \
+  --timeout 120

lilac/.gitignore

@@ -0,0 +1 @@
+web/

lilac/__init__.py

@@ -0,0 +1,42 @@
+from importlib import metadata
+
+from .concepts import *  # noqa: F403
+from .config import DatasetConfig, DatasetSettings, EmbeddingConfig, SignalConfig
+from .data import *  # noqa: F403
+from .data.dataset_duckdb import DatasetDuckDB
+from .data_loader import create_dataset
+from .db_manager import get_dataset, set_default_dataset_cls
+from .embeddings import *  # noqa: F403
+from .embeddings.default_vector_stores import register_default_vector_stores
+from .schema import *  # noqa: F403
+from .server import start_server, stop_server
+from .signals import *  # noqa: F403
+from .signals.default_signals import register_default_signals
+from .sources import *  # noqa: F403
+from .sources.default_sources import register_default_sources
+from .splitters import *  # noqa: F403
+
+try:
+  __version__ = metadata.version('lilacai')
+except metadata.PackageNotFoundError:
+  __version__ = ''
+
+register_default_sources()
+register_default_signals()
+register_default_vector_stores()
+set_default_dataset_cls(DatasetDuckDB)
+
+# Avoids polluting the results of dir(__package__).
+del (metadata, register_default_sources, register_default_signals, set_default_dataset_cls,
+     DatasetDuckDB)
+
+__all__ = [
+  'start_server',
+  'stop_server',
+  'create_dataset',
+  'get_dataset',
+  'DatasetConfig',
+  'EmbeddingConfig',
+  'SignalConfig',
+  'DatasetSettings',
+]

lilac/auth.py

@@ -0,0 +1,87 @@
+"""Authentication and ACL configuration."""
+
+from typing import Optional
+
+from fastapi import Request
+from pydantic import BaseModel, ValidationError
+
+from .env import env
+
+
+class ConceptAuthorizationException(Exception):
+  """Authorization exceptions thrown by the concept database."""
+  pass
+
+
+class DatasetUserAccess(BaseModel):
+  """User access for datasets."""
+  # Whether the user can compute a signal.
+  compute_signals: bool
+  # Whether the user can delete a dataset.
+  delete_dataset: bool
+  # Whether the user can delete a signal.
+  delete_signals: bool
+  # Whether the user can update settings.
+  update_settings: bool
+
+
+class ConceptUserAccess(BaseModel):
+  """User access for concepts."""
+  # Whether the user can delete any concept (not their own).
+  delete_any_concept: bool
+
+
+class UserAccess(BaseModel):
+  """User access."""
+  create_dataset: bool
+
+  # TODO(nsthorat): Make this keyed to each dataset and concept.
+  dataset: DatasetUserAccess
+  concept: ConceptUserAccess
+
+
+class UserInfo(BaseModel):
+  """User information."""
+  id: str
+  email: str
+  name: str
+  given_name: str
+  family_name: str
+
+
+class AuthenticationInfo(BaseModel):
+  """Authentication information for the user."""
+  user: Optional[UserInfo] = None
+  access: UserAccess
+  auth_enabled: bool
+
+
+def get_session_user(request: Request) -> Optional[UserInfo]:
+  """Get the user from the session."""
+  if not env('LILAC_AUTH_ENABLED'):
+    return None
+  user_info_dict = request.session.get('user', None)
+  if user_info_dict:
+    try:
+      return UserInfo.parse_obj(user_info_dict)
+    except ValidationError:
+      return None
+  return None
+
+
+def get_user_access() -> UserAccess:
+  """Get the user access."""
+  auth_enabled = env('LILAC_AUTH_ENABLED')
+  if isinstance(auth_enabled, str):
+    auth_enabled = auth_enabled.lower() == 'true'
+  if auth_enabled:
+    return UserAccess(
+      create_dataset=False,
+      dataset=DatasetUserAccess(
+        compute_signals=False, delete_dataset=False, delete_signals=False, update_settings=False),
+      concept=ConceptUserAccess(delete_any_concept=False))
+  return UserAccess(
+    create_dataset=True,
+    dataset=DatasetUserAccess(
+      compute_signals=True, delete_dataset=True, delete_signals=True, update_settings=True),
+    concept=ConceptUserAccess(delete_any_concept=True))

lilac/batch_utils.py

@@ -0,0 +1,92 @@
+"""Utils for the python server."""
+import itertools
+from typing import Any, Callable, Generator, Iterable, Iterator, TypeVar, Union, cast
+
+from .schema import Item
+from .utils import chunks, is_primitive
+
+
+def _deep_flatten(input: Union[Iterator, object],
+                  is_primitive_predicate: Callable[[object], bool]) -> Generator:
+  """Flattens a nested iterable."""
+  if is_primitive_predicate(input):
+    yield input
+  elif isinstance(input, dict):
+    yield input
+  elif is_primitive(input):
+    yield input
+  else:
+    for elem in cast(Iterator, input):
+      yield from _deep_flatten(elem, is_primitive_predicate)
+
+
+def deep_flatten(input: Union[Iterator, Iterable],
+                 is_primitive_predicate: Callable[[object], bool] = is_primitive) -> Iterator:
+  """Flattens a deeply nested iterator.
+
+  Primitives and dictionaries are not flattened. The user can also provide a predicate to determine
+  what is a primitive.
+  """
+  return _deep_flatten(input, is_primitive_predicate)
+
+
+def _deep_unflatten(flat_input: Iterator[list[object]], original_input: Union[Iterable, object],
+                    is_primitive_predicate: Callable[[object], bool]) -> Union[list, dict]:
+  """Unflattens a deeply flattened iterable according to the original iterable's structure."""
+  if is_primitive_predicate(original_input):
+    return next(flat_input)
+  else:
+    values: Iterable
+    if isinstance(original_input, dict):
+      values = original_input.values()
+    else:
+      values = cast(Iterable, original_input)
+    return [_deep_unflatten(flat_input, orig_elem, is_primitive_predicate) for orig_elem in values]
+
+
+def deep_unflatten(flat_input: Union[Iterable, Iterator],
+                   original_input: Union[Iterable, object],
+                   is_primitive_predicate: Callable[[object], bool] = is_primitive) -> list:
+  """Unflattens a deeply flattened iterable according to the original iterable's structure."""
+  return cast(list, _deep_unflatten(iter(flat_input), original_input, is_primitive_predicate))
+
+
+TFlatten = TypeVar('TFlatten')
+
+
+def flatten(inputs: Iterable[Iterable[TFlatten]]) -> Iterator[TFlatten]:
+  """Flattens a nested iterator.
+
+  Only supports flattening one level deep.
+  """
+  for input in inputs:
+    yield from input
+
+
+TUnflatten = TypeVar('TUnflatten')
+
+
+def unflatten(flat_inputs: Union[Iterable[TUnflatten], Iterator[TUnflatten]],
+              original_inputs: Iterable[Iterable[Any]]) -> Iterator[list[TUnflatten]]:
+  """Unflattens a flattened iterable according to the original iterable's structure."""
+  flat_inputs_iter = iter(flat_inputs)
+  for original_input in original_inputs:
+    yield [next(flat_inputs_iter) for _ in original_input]
+
+
+TFlatBatchedInput = TypeVar('TFlatBatchedInput')
+TFlatBatchedOutput = TypeVar('TFlatBatchedOutput')
+
+
+def flat_batched_compute(input: Iterable[Iterable[TFlatBatchedInput]],
+                         f: Callable[[list[TFlatBatchedInput]], Iterable[TFlatBatchedOutput]],
+                         batch_size: int) -> Iterable[Iterable[TFlatBatchedOutput]]:
+  """Flatten the input, batched call f, and return the output unflattened."""
+  # Tee the input so we can use it twice for the input and output shapes.
+  input_1, input_2 = itertools.tee(input, 2)
+  batches = chunks(flatten(input_1), batch_size)
+  batched_outputs = flatten((f(batch) for batch in batches))
+  return unflatten(batched_outputs, input_2)
+
+
+TBatchSpanVectorOutput = TypeVar('TBatchSpanVectorOutput', bound=Item)

lilac/cli.py

@@ -0,0 +1,47 @@
+"""Lilac CLI."""
+
+import click
+
+from . import __version__
+from .concepts.db_concept import DISK_CONCEPT_DB
+from .load import load_command as load
+from .server import start_server
+
+
+@click.command()
+@click.option(
+  '--host',
+  help='The host address where the web server will listen to.',
+  default='0.0.0.0',
+  type=str)
+@click.option('--port', help='The port number of the web-server', type=int, default=5432)
+def start(host: str, port: int) -> None:
+  """Starts the Lilac web server."""
+  start_server(host=host, port=port, open=True)
+
+
+@click.command()
+def version() -> None:
+  """Prints the version of Lilac."""
+  print(__version__)
+
+
+@click.command()
+def concepts() -> None:
+  """Lists lilac concepts."""
+  print(DISK_CONCEPT_DB.list())
+
+
+@click.group()
+def cli() -> None:
+  """Lilac CLI."""
+  pass
+
+
+cli.add_command(start)
+cli.add_command(version)
+cli.add_command(load)
+cli.add_command(concepts)
+
+if __name__ == '__main__':
+  cli()

lilac/concepts/__init__.py

@@ -0,0 +1,12 @@
+"""Concepts are customizable signals that help enrich documents."""
+
+from .concept import Example, ExampleIn
+from .db_concept import ConceptUpdate, DiskConceptDB, DiskConceptModelDB
+
+__all__ = [
+  'DiskConceptDB',
+  'DiskConceptModelDB',
+  'Example',
+  'ExampleIn',
+  'ConceptUpdate',
+]

lilac/concepts/concept.py

@@ -0,0 +1,339 @@
+"""Defines the concept and the concept models."""
+import dataclasses
+from enum import Enum
+from typing import Callable, Literal, Optional, Union
+
+import numpy as np
+from joblib import Parallel, delayed
+from pydantic import BaseModel, validator
+from scipy.interpolate import interp1d
+from sklearn.base import clone
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import precision_recall_curve, roc_auc_score
+from sklearn.model_selection import KFold
+
+from ..embeddings.embedding import get_embed_fn
+from ..signal import TextEmbeddingSignal, get_signal_cls
+from ..utils import DebugTimer
+
+LOCAL_CONCEPT_NAMESPACE = 'local'
+
+# The maximum number of cross-validation models to train.
+MAX_NUM_CROSS_VAL_MODELS = 15
+# The β weight to use for the F-beta score: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.fbeta_score.html
+# β = 0.5 means we value precision 2x as much as recall.
+# β = 2 means we value recall 2x as much as precision.
+F_BETA_WEIGHT = 0.5
+
+
+class ConceptType(str, Enum):
+  """Enum holding the concept type."""
+  TEXT = 'text'
+  IMAGE = 'image'
+
+  def __repr__(self) -> str:
+    return self.value
+
+
+class ExampleOrigin(BaseModel):
+  """The origin of an example."""
+  # The namespace that holds the dataset.
+  dataset_namespace: str
+
+  # The name of the dataset.
+  dataset_name: str
+
+  # The id of row in the dataset that the example was added from.
+  dataset_row_id: str
+
+
+DraftId = Union[Literal['main'], str]
+DRAFT_MAIN = 'main'
+
+
+class ExampleIn(BaseModel):
+  """An example in a concept without the id (used for adding new examples)."""
+  label: bool
+  text: Optional[str] = None
+  img: Optional[bytes] = None
+  origin: Optional[ExampleOrigin] = None
+  # The name of the draft to put the example in. If None, puts it in the main draft.
+  draft: Optional[DraftId] = DRAFT_MAIN
+
+  @validator('text')
+  def parse_text(cls, text: str) -> str:
+    """Fixes surrogate errors in text: https://github.com/ijl/orjson/blob/master/README.md#str ."""
+    return text.encode('utf-8', 'replace').decode('utf-8')
+
+
+class Example(ExampleIn):
+  """A single example in a concept used for training a concept model."""
+  id: str
+
+
+class Concept(BaseModel):
+  """A concept is a collection of examples."""
+  # The namespace of the concept.
+  namespace: str
+  # The name of the concept.
+  concept_name: str
+  # The type of the data format that this concept represents.
+  type: ConceptType
+  data: dict[str, Example]
+  version: int = 0
+
+  tags: list[str] = []
+  description: Optional[str] = None
+
+  def drafts(self) -> list[DraftId]:
+    """Gets all the drafts for the concept."""
+    drafts: set[DraftId] = set([DRAFT_MAIN])  # Always return the main draft.
+    for example in self.data.values():
+      if example.draft:
+        drafts.add(example.draft)
+    return list(sorted(drafts))
+
+
+class OverallScore(str, Enum):
+  """Enum holding the overall score."""
+  NOT_GOOD = 'not_good'
+  OK = 'ok'
+  GOOD = 'good'
+  VERY_GOOD = 'very_good'
+  GREAT = 'great'
+
+
+def _get_overall_score(f1_score: float) -> OverallScore:
+  if f1_score < 0.5:
+    return OverallScore.NOT_GOOD
+  if f1_score < 0.8:
+    return OverallScore.OK
+  if f1_score < 0.9:
+    return OverallScore.GOOD
+  if f1_score < 0.95:
+    return OverallScore.VERY_GOOD
+  return OverallScore.GREAT
+
+
+class ConceptMetrics(BaseModel):
+  """Metrics for a concept."""
+  # The average F1 score for the concept computed using cross validation.
+  f1: float
+  precision: float
+  recall: float
+  roc_auc: float
+  overall: OverallScore
+
+
+@dataclasses.dataclass
+class LogisticEmbeddingModel:
+  """A model that uses logistic regression with embeddings."""
+
+  _metrics: Optional[ConceptMetrics] = None
+  _threshold: float = 0.5
+
+  def __post_init__(self) -> None:
+    # See `notebooks/Toxicity.ipynb` for an example of training a concept model.
+    self._model = LogisticRegression(
+      class_weight='balanced', C=30, tol=1e-5, warm_start=True, max_iter=5_000, n_jobs=-1)
+
+  def score_embeddings(self, embeddings: np.ndarray) -> np.ndarray:
+    """Get the scores for the provided embeddings."""
+    y_probs = self._model.predict_proba(embeddings)[:, 1]
+    # Map [0, threshold, 1] to [0, 0.5, 1].
+    interpolate_fn = interp1d([0, self._threshold, 1], [0, 0.4999, 1])
+    return interpolate_fn(y_probs)
+
+  def _setup_training(self, X_train: np.ndarray,
+                      labels: Union[list[bool], np.ndarray]) -> tuple[np.ndarray, np.ndarray]:
+    y_train = np.array(labels)
+    # Shuffle the data in unison.
+    p = np.random.permutation(len(X_train))
+    X_train = X_train[p]
+    y_train = y_train[p]
+    return X_train, y_train
+
+  def fit(self, embeddings: np.ndarray, labels: list[bool]) -> None:
+    """Fit the model to the provided embeddings and labels."""
+    label_set = set(labels)
+    if len(label_set) < 2:
+      dim = embeddings.shape[1]
+      random_vector = np.random.randn(dim).astype(np.float32)
+      random_vector /= np.linalg.norm(random_vector)
+      embeddings = np.vstack([embeddings, random_vector])
+      labels.append(False if True in label_set else True)
+
+    if len(labels) != len(embeddings):
+      raise ValueError(
+        f'Length of embeddings ({len(embeddings)}) must match length of labels ({len(labels)})')
+    X_train, y_train = self._setup_training(embeddings, labels)
+    self._model.fit(X_train, y_train)
+    self._metrics, self._threshold = self._compute_metrics(embeddings, labels)
+
+  def _compute_metrics(self, embeddings: np.ndarray,
+                       labels: list[bool]) -> tuple[Optional[ConceptMetrics], float]:
+    """Return the concept metrics."""
+    labels_np = np.array(labels)
+    n_splits = min(len(labels_np), MAX_NUM_CROSS_VAL_MODELS)
+    fold = KFold(n_splits, shuffle=True, random_state=42)
+
+    def _fit_and_score(model: LogisticRegression, X_train: np.ndarray, y_train: np.ndarray,
+                       X_test: np.ndarray, y_test: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+      if len(set(y_train)) < 2:
+        return np.array([]), np.array([])
+      model.fit(X_train, y_train)
+      y_pred = model.predict_proba(X_test)[:, 1]
+      return y_test, y_pred
+
+    # Compute the metrics for each validation fold in parallel.
+    jobs: list[Callable] = []
+    for (train_index, test_index) in fold.split(embeddings):
+      X_train, y_train = embeddings[train_index], labels_np[train_index]
+      X_train, y_train = self._setup_training(X_train, y_train)
+      X_test, y_test = embeddings[test_index], labels_np[test_index]
+      model = clone(self._model)
+      jobs.append(delayed(_fit_and_score)(model, X_train, y_train, X_test, y_test))
+    results = Parallel(n_jobs=-1)(jobs)
+
+    y_test = np.concatenate([y_test for y_test, _ in results], axis=0)
+    y_pred = np.concatenate([y_pred for _, y_pred in results], axis=0)
+    if len(set(y_test)) < 2:
+      return None, 0.5
+    roc_auc_val = roc_auc_score(y_test, y_pred)
+    precision, recall, thresholds = precision_recall_curve(y_test, y_pred)
+    numerator = (1 + F_BETA_WEIGHT**2) * precision * recall
+    denom = (F_BETA_WEIGHT**2 * precision) + recall
+    f1_scores = np.divide(numerator, denom, out=np.zeros_like(denom), where=(denom != 0))
+    max_f1: float = np.max(f1_scores)
+    max_f1_index = np.argmax(f1_scores)
+    max_f1_thresh: float = thresholds[max_f1_index]
+    max_f1_prec: float = precision[max_f1_index]
+    max_f1_recall: float = recall[max_f1_index]
+    metrics = ConceptMetrics(
+      f1=max_f1,
+      precision=max_f1_prec,
+      recall=max_f1_recall,
+      roc_auc=float(roc_auc_val),
+      overall=_get_overall_score(max_f1))
+    return metrics, max_f1_thresh
+
+
+def draft_examples(concept: Concept, draft: DraftId) -> dict[str, Example]:
+  """Get the examples in the provided draft by overriding the main draft."""
+  draft_examples: dict[str, dict[str, Example]] = {}
+  for id, example in concept.data.items():
+    draft_examples.setdefault(example.draft or DRAFT_MAIN, {})[example.id] = example
+
+  if draft == DRAFT_MAIN:
+    return draft_examples.get(DRAFT_MAIN, {})
+
+  if draft not in draft_examples:
+    raise ValueError(
+      f'Draft {draft} not found in concept. Found drafts: {list(draft_examples.keys())}')
+
+  # Map the text of the draft to its id so we can dedupe with main.
+  draft_text_ids = {example.text: id for id, example in draft_examples[draft].items()}
+
+  # Write each of examples from main to the draft examples only if the text does not appear in the
+  # draft.
+  for id, example in draft_examples[DRAFT_MAIN].items():
+    if example.text not in draft_text_ids:
+      draft_examples[draft][id] = example
+
+  return draft_examples[draft]
+
+
+@dataclasses.dataclass
+class ConceptModel:
+  """A concept model. Stores all concept model drafts and manages syncing."""
+  # The concept that this model is for.
+  namespace: str
+  concept_name: str
+
+  # The name of the embedding for this model.
+  embedding_name: str
+  version: int = 0
+
+  batch_size = 4096
+
+  # The following fields are excluded from JSON serialization, but still pickle-able.
+  # Maps a concept id to the embeddings.
+  _embeddings: dict[str, np.ndarray] = dataclasses.field(default_factory=dict)
+  _logistic_models: dict[DraftId, LogisticEmbeddingModel] = dataclasses.field(default_factory=dict)
+
+  def get_metrics(self) -> Optional[ConceptMetrics]:
+    """Return the metrics for this model."""
+    return self._get_logistic_model(DRAFT_MAIN)._metrics
+
+  def score_embeddings(self, draft: DraftId, embeddings: np.ndarray) -> np.ndarray:
+    """Get the scores for the provided embeddings."""
+    return self._get_logistic_model(draft).score_embeddings(embeddings)
+
+  def coef(self, draft: DraftId) -> np.ndarray:
+    """Get the coefficients of the underlying ML model."""
+    return self._get_logistic_model(draft)._model.coef_.reshape(-1)
+
+  def _get_logistic_model(self, draft: DraftId) -> LogisticEmbeddingModel:
+    """Get the logistic model for the provided draft."""
+    if draft not in self._logistic_models:
+      self._logistic_models[draft] = LogisticEmbeddingModel()
+    return self._logistic_models[draft]
+
+  def sync(self, concept: Concept) -> bool:
+    """Update the model with the latest labeled concept data."""
+    if concept.version == self.version:
+      # The model is up to date.
+      return False
+
+    concept_path = (f'{self.namespace}/{self.concept_name}/'
+                    f'{self.embedding_name}')
+    with DebugTimer(f'Computing embeddings for "{concept_path}"'):
+      self._compute_embeddings(concept)
+
+    # Fit each of the drafts, sort by draft name for deterministic behavior.
+    for draft in concept.drafts():
+      examples = draft_examples(concept, draft)
+      embeddings = np.array([self._embeddings[id] for id in examples.keys()])
+      labels = [example.label for example in examples.values()]
+      model = self._get_logistic_model(draft)
+      with DebugTimer(f'Fitting model for "{concept_path}"'):
+        model.fit(embeddings, labels)
+
+    # Synchronize the model version with the concept version.
+    self.version = concept.version
+
+    return True
+
+  def _compute_embeddings(self, concept: Concept) -> None:
+    signal_cls = get_signal_cls(self.embedding_name)
+    if not signal_cls:
+      raise ValueError(f'Embedding signal "{self.embedding_name}" not found in the registry.')
+    embedding_signal = signal_cls()
+    if not isinstance(embedding_signal, TextEmbeddingSignal):
+      raise ValueError(f'Only text embedding signals are currently supported for concepts. '
+                       f'"{self.embedding_name}" is a {type(embedding_signal)}.')
+
+    embed_fn = get_embed_fn(self.embedding_name, split=False)
+    concept_embeddings: dict[str, np.ndarray] = {}
+
+    examples = concept.data.items()
+    if not examples:
+      raise ValueError(f'Cannot sync concept "{concept.concept_name}". It has no examples.')
+
+    # Compute the embeddings for the examples with cache miss.
+    texts_of_missing_embeddings: dict[str, str] = {}
+    for id, example in examples:
+      if id in self._embeddings:
+        # Cache hit.
+        concept_embeddings[id] = self._embeddings[id]
+      else:
+        # Cache miss.
+        # TODO(smilkov): Support images.
+        texts_of_missing_embeddings[id] = example.text or ''
+
+    missing_ids = texts_of_missing_embeddings.keys()
+    missing_embeddings = embed_fn(list(texts_of_missing_embeddings.values()))
+
+    for id, (embedding,) in zip(missing_ids, missing_embeddings):
+      concept_embeddings[id] = embedding['vector'] / np.linalg.norm(embedding['vector'])
+    self._embeddings = concept_embeddings

lilac/concepts/db_concept.py

@@ -0,0 +1,567 @@
+"""The concept database."""
+
+import abc
+import glob
+import json
+import os
+import pathlib
+import pickle
+import shutil
+import threading
+
+# NOTE: We have to import the module for uuid so it can be mocked.
+import uuid
+from importlib import resources
+from typing import Any, List, Optional, Union, cast
+
+from pydantic import BaseModel
+from typing_extensions import override
+
+from ..auth import ConceptAuthorizationException, UserInfo
+from ..env import data_path, env
+from ..schema import SignalInputType
+from ..signal import get_signal_cls
+from ..utils import delete_file, file_exists, get_lilac_cache_dir, open_file
+from .concept import DRAFT_MAIN, Concept, ConceptModel, ConceptType, DraftId, Example, ExampleIn
+
+CONCEPTS_DIR = 'concept'
+CONCEPT_JSON_FILENAME = 'concept.json'
+# Under 'lilac' package.
+LILAC_CONCEPTS_DIR = 'concepts'
+
+
+class ConceptNamespaceACL(BaseModel):
+  """The access control list for a namespace."""
+  # Whether the current user can read concepts in the namespace.
+  read: bool
+  # Whether the current user can add concepts to the namespace.
+  write: bool
+
+
+class ConceptACL(BaseModel):
+  """The access control list for an individual concept."""
+  # Whether the current user can read the concept.
+  read: bool
+  # Whether the current user can edit the concept, including adding examples or deleting the
+  # concept.
+  write: bool
+
+
+class ConceptInfo(BaseModel):
+  """Information about a concept."""
+  namespace: str
+  name: str
+  description: Optional[str] = None
+  type: ConceptType
+  drafts: list[DraftId]
+  tags: list[str] = []
+
+  acls: ConceptACL
+
+
+class ConceptUpdate(BaseModel):
+  """An update to a concept."""
+  # List of examples to be inserted.
+  insert: Optional[list[ExampleIn]] = []
+
+  # List of examples to be updated.
+  update: Optional[list[Example]] = []
+
+  # The ids of the examples to be removed.
+  remove: Optional[list[str]] = []
+
+
+class ConceptDB(abc.ABC):
+  """Interface for the concept database."""
+
+  @abc.abstractmethod
+  def list(self, user: Optional[UserInfo] = None) -> list[ConceptInfo]:
+    """List all the concepts."""
+    pass
+
+  @abc.abstractmethod
+  def namespace_acls(self, namespace: str, user: Optional[UserInfo] = None) -> ConceptNamespaceACL:
+    """Return the ACL for a namespace."""
+    pass
+
+  @abc.abstractmethod
+  def concept_acls(self, namespace: str, name: str, user: Optional[UserInfo] = None) -> ConceptACL:
+    """Return the ACL for a concept."""
+    pass
+
+  @abc.abstractmethod
+  def get(self, namespace: str, name: str, user: Optional[UserInfo] = None) -> Optional[Concept]:
+    """Return a concept or None if there isn't one."""
+    pass
+
+  @abc.abstractmethod
+  def create(self,
+             namespace: str,
+             name: str,
+             type: Union[ConceptType, str],
+             description: Optional[str] = None,
+             user: Optional[UserInfo] = None) -> Concept:
+    """Create a concept.
+
+    Args:
+      namespace: The namespace of the concept.
+      name: The name of the concept.
+      type: The type of the concept.
+      description: The description of the concept.
+      user: The user creating the concept, if authentication is enabled.
+    """
+    pass
+
+  @abc.abstractmethod
+  def edit(self,
+           namespace: str,
+           name: str,
+           change: ConceptUpdate,
+           user: Optional[UserInfo] = None) -> Concept:
+    """Edit a concept. If the concept doesn't exist, throw an error."""
+    pass
+
+  @abc.abstractmethod
+  def remove(self, namespace: str, name: str, user: Optional[UserInfo] = None) -> None:
+    """Remove a concept."""
+    pass
+
+  @abc.abstractmethod
+  def merge_draft(self,
+                  namespace: str,
+                  name: str,
+                  draft: DraftId,
+                  user: Optional[UserInfo] = None) -> Concept:
+    """Merge a draft concept.."""
+    pass
+
+
+class ConceptModelDB(abc.ABC):
+  """Interface for the concept model database."""
+
+  _concept_db: ConceptDB
+  _sync_lock = threading.Lock()
+
+  def __init__(self, concept_db: ConceptDB) -> None:
+    self._concept_db = concept_db
+
+  @abc.abstractmethod
+  def create(self,
+             namespace: str,
+             concept_name: str,
+             embedding_name: str,
+             user: Optional[UserInfo] = None) -> ConceptModel:
+    """Create the concept model."""
+    pass
+
+  @abc.abstractmethod
+  def get(self,
+          namespace: str,
+          concept_name: str,
+          embedding_name: str,
+          user: Optional[UserInfo] = None) -> Optional[ConceptModel]:
+    """Get the model associated with the provided concept the embedding.
+
+    Returns None if the model does not exist.
+    """
+    pass
+
+  @abc.abstractmethod
+  def _save(self, model: ConceptModel) -> None:
+    """Save the concept model."""
+    pass
+
+  def in_sync(self, model: ConceptModel, user: Optional[UserInfo] = None) -> bool:
+    """Return True if the model is up to date with the concept."""
+    concept = self._concept_db.get(model.namespace, model.concept_name, user=user)
+    if not concept:
+      raise ValueError(f'Concept "{model.namespace}/{model.concept_name}" does not exist.')
+    return concept.version == model.version
+
+  def sync(self,
+           namespace: str,
+           concept_name: str,
+           embedding_name: str,
+           user: Optional[UserInfo] = None,
+           create: bool = False) -> ConceptModel:
+    """Sync the concept model. Returns true if the model was updated."""
+    with self._sync_lock:
+      model = self.get(namespace, concept_name, embedding_name, user=user)
+      if not model:
+        if create:
+          model = self.create(namespace, concept_name, embedding_name, user=user)
+        else:
+          raise ValueError(f'Model "{namespace}/{concept_name}/{embedding_name}" does not exist.')
+
+      concept = self._concept_db.get(model.namespace, model.concept_name, user=user)
+      if not concept:
+        raise ValueError(f'Concept "{model.namespace}/{model.concept_name}" does not exist.')
+      model_updated = model.sync(concept)
+      if model_updated:
+        self._save(model)
+      return model
+
+  @abc.abstractmethod
+  def remove(self, namespace: str, concept_name: str, embedding_name: str) -> None:
+    """Remove the model of a concept."""
+    pass
+
+  @abc.abstractmethod
+  def get_models(self, namespace: str, concept_name: str) -> list[ConceptModel]:
+    """List all the models associated with a concept."""
+    pass
+
+
+class DiskConceptModelDB(ConceptModelDB):
+  """Interface for the concept model database."""
+
+  def __init__(self,
+               concept_db: ConceptDB,
+               base_dir: Optional[Union[str, pathlib.Path]] = None) -> None:
+    super().__init__(concept_db)
+    self._base_dir = base_dir
+
+  def _get_base_dir(self) -> str:
+    return str(self._base_dir) if self._base_dir else data_path()
+
+  @override
+  def create(self,
+             namespace: str,
+             concept_name: str,
+             embedding_name: str,
+             user: Optional[UserInfo] = None) -> ConceptModel:
+    if self.get(namespace, concept_name, embedding_name, user=user):
+      raise ValueError('Concept model already exists.')
+    concept = self._concept_db.get(namespace, concept_name, user=user)
+    if not concept:
+      raise ValueError(f'Concept "{namespace}/{concept_name}" does not exist.')
+    model = ConceptModel(
+      namespace=namespace, concept_name=concept_name, embedding_name=embedding_name)
+    self._save(model)
+    return model
+
+  @override
+  def get(self,
+          namespace: str,
+          concept_name: str,
+          embedding_name: str,
+          user: Optional[UserInfo] = None) -> Optional[ConceptModel]:
+    # Make sure the concept exists.
+    concept = self._concept_db.get(namespace, concept_name, user=user)
+    if not concept:
+      raise ValueError(f'Concept "{namespace}/{concept_name}" does not exist.')
+
+    # Make sure that the embedding signal exists.
+    if not get_signal_cls(embedding_name):
+      raise ValueError(f'Embedding signal "{embedding_name}" not found in the registry.')
+
+    concept_model_path = _concept_model_path(self._get_base_dir(), namespace, concept_name,
+                                             embedding_name)
+    if not file_exists(concept_model_path):
+      return None
+
+    with open_file(concept_model_path, 'rb') as f:
+      return pickle.load(f)
+
+  def _save(self, model: ConceptModel) -> None:
+    """Save the concept model."""
+    concept_model_path = _concept_model_path(self._get_base_dir(), model.namespace,
+                                             model.concept_name, model.embedding_name)
+    with open_file(concept_model_path, 'wb') as f:
+      pickle.dump(model, f)
+
+  @override
+  def remove(self,
+             namespace: str,
+             concept_name: str,
+             embedding_name: str,
+             user: Optional[UserInfo] = None) -> None:
+    concept_model_path = _concept_model_path(self._get_base_dir(), namespace, concept_name,
+                                             embedding_name)
+
+    if not file_exists(concept_model_path):
+      raise ValueError(f'Concept model {namespace}/{concept_name}/{embedding_name} does not exist.')
+
+    delete_file(concept_model_path)
+
+  @override
+  def get_models(self,
+                 namespace: str,
+                 concept_name: str,
+                 user: Optional[UserInfo] = None) -> list[ConceptModel]:
+    """List all the models associated with a concept."""
+    model_files = glob.iglob(
+      os.path.join(_concept_cache_dir(self._get_base_dir(), namespace, concept_name), '*.pkl'))
+    models: list[ConceptModel] = []
+    for model_file in model_files:
+      embedding_name = os.path.basename(model_file)[:-len('.pkl')]
+      model = self.get(namespace, concept_name, embedding_name, user=user)
+      if model:
+        models.append(model)
+    return models
+
+
+def get_concept_output_dir(base_dir: str, namespace: str, name: str) -> str:
+  """Return the output directory for a given concept."""
+  if namespace == 'lilac':
+    # Lilac concepts are stored in the resources directory and shipped with the pip package.
+    return str(resources.files('lilac').joinpath(os.path.join(LILAC_CONCEPTS_DIR, name)))
+
+  return os.path.join(base_dir, CONCEPTS_DIR, namespace, name)
+
+
+def _concept_json_path(base_dir: str, namespace: str, name: str) -> str:
+  return os.path.join(get_concept_output_dir(base_dir, namespace, name), CONCEPT_JSON_FILENAME)
+
+
+def _concept_cache_dir(base_dir: str, namespace: str, concept_name: str) -> str:
+  return os.path.join(get_lilac_cache_dir(base_dir), CONCEPTS_DIR, namespace, concept_name)
+
+
+def _concept_model_path(base_dir: str, namespace: str, concept_name: str,
+                        embedding_name: str) -> str:
+
+  return os.path.join(
+    _concept_cache_dir(base_dir, namespace, concept_name), f'{embedding_name}.pkl')
+
+
+class DiskConceptDB(ConceptDB):
+  """A concept database."""
+
+  def __init__(self, base_dir: Optional[Union[str, pathlib.Path]] = None) -> None:
+    self._base_dir = base_dir
+
+  def _get_base_dir(self) -> str:
+    return str(self._base_dir) if self._base_dir else data_path()
+
+  @override
+  def namespace_acls(self, namespace: str, user: Optional[UserInfo] = None) -> ConceptNamespaceACL:
+    if not env('LILAC_AUTH_ENABLED'):
+      return ConceptNamespaceACL(read=True, write=True)
+
+    if namespace == 'lilac':
+      return ConceptNamespaceACL(read=True, write=False)
+    if user and user.id == namespace:
+      return ConceptNamespaceACL(read=True, write=True)
+
+    return ConceptNamespaceACL(read=False, write=False)
+
+  @override
+  def concept_acls(self, namespace: str, name: str, user: Optional[UserInfo] = None) -> ConceptACL:
+    namespace_acls = self.namespace_acls(namespace, user=user)
+    # Concept ACL inherit from the namespace ACL. We currently don't have concept-specific
+    #  ACL.
+    return ConceptACL(read=namespace_acls.read, write=namespace_acls.write)
+
+  @override
+  def list(self, user: Optional[UserInfo] = None) -> list[ConceptInfo]:
+    namespaces: Optional[list[str]] = None
+    if env('LILAC_AUTH_ENABLED'):
+      namespaces = ['lilac']
+      if user:
+        namespaces += [user.id]
+
+    concept_infos: list[ConceptInfo] = []
+
+    namespace_concept_dirs: list[tuple[Optional[str], str]] = [
+      # None = Read the namespace from the directory.
+      (None, os.path.join(self._get_base_dir(), CONCEPTS_DIR)),
+      # Read lilac concepts from the resources directory.
+      ('lilac', str(resources.files('lilac').joinpath(LILAC_CONCEPTS_DIR)))
+    ]
+
+    for (default_namespace, concept_dir) in namespace_concept_dirs:
+      # Read the concepts from the data dir and return a ConceptInfo containing the namespace and
+      # name.
+      for root, _, files in os.walk(concept_dir):
+        for file in files:
+          if file == CONCEPT_JSON_FILENAME:
+            namespace, name = root.split('/')[-2:]
+            if default_namespace is not None:
+              namespace = default_namespace
+            if namespaces and namespace not in namespaces:
+              # Ignore concepts that are not in the namespace, if provided.
+              continue
+
+            concept = cast(Concept, self.get(namespace, name, user=user))
+            concept_infos.append(
+              _info_from_concept(concept, self.concept_acls(namespace, name, user=user)))
+
+    return concept_infos
+
+  @override
+  def get(self, namespace: str, name: str, user: Optional[UserInfo] = None) -> Optional[Concept]:
+    # If the user does not have access to the concept, return None.
+    acls = self.concept_acls(namespace, name, user=user)
+    if not acls.read:
+      raise ConceptAuthorizationException(
+        f'Concept "{namespace}/{name}" does not exist or user does not have access.')
+
+    concept_json_path = _concept_json_path(self._get_base_dir(), namespace, name)
+    if not file_exists(concept_json_path):
+      return None
+
+    with open_file(concept_json_path) as f:
+      obj: dict[str, Any] = json.load(f)
+      if 'namespace' not in obj:
+        obj['namespace'] = namespace
+      return Concept.parse_obj(obj)
+
+  @override
+  def create(self,
+             namespace: str,
+             name: str,
+             type: Union[ConceptType, str] = ConceptType.TEXT,
+             description: Optional[str] = None,
+             user: Optional[UserInfo] = None) -> Concept:
+    """Create a concept."""
+    # If the user does not have access to the write to the concept namespace, throw.
+    acls = self.namespace_acls(namespace, user=user)
+    if not acls.write:
+      raise ConceptAuthorizationException(
+        f'Concept namespace "{namespace}" does not exist or user does not have access.')
+
+    concept_json_path = _concept_json_path(self._get_base_dir(), namespace, name)
+    if file_exists(concept_json_path):
+      raise ValueError(f'Concept with namespace "{namespace}" and name "{name}" already exists.')
+
+    if isinstance(type, str):
+      type = ConceptType(type)
+    concept = Concept(
+      namespace=namespace, concept_name=name, type=type, data={}, description=description)
+    self._save(concept)
+    return concept
+
+  def _validate_examples(self, examples: List[Union[ExampleIn, Example]],
+                         type: ConceptType) -> None:
+    for example in examples:
+      inferred_type = 'text' if example.text else 'unknown'
+      if inferred_type != type:
+        raise ValueError(f'Example type "{inferred_type}" does not match concept type "{type}".')
+
+  @override
+  def edit(self,
+           namespace: str,
+           name: str,
+           change: ConceptUpdate,
+           user: Optional[UserInfo] = None) -> Concept:
+    # If the user does not have access to the concept, return None.
+    acls = self.concept_acls(namespace, name, user=user)
+    if not acls.write:
+      raise ConceptAuthorizationException(
+        f'Concept "{namespace}/{name}" does not exist or user does not have access.')
+
+    concept_json_path = _concept_json_path(self._get_base_dir(), namespace, name)
+
+    if not file_exists(concept_json_path):
+      raise ValueError(f'Concept with namespace "{namespace}" and name "{name}" does not exist. '
+                       'Please call create() first.')
+
+    inserted_points = change.insert or []
+    updated_points = change.update or []
+    removed_points = change.remove or []
+
+    concept = cast(Concept, self.get(namespace, name, user=user))
+
+    self._validate_examples([*inserted_points, *updated_points], concept.type)
+
+    for remove_example in removed_points:
+      if remove_example not in concept.data:
+        raise ValueError(f'Example with id "{remove_example}" does not exist.')
+      concept.data.pop(remove_example)
+
+    for example in inserted_points:
+      id = uuid.uuid4().hex
+      concept.data[id] = Example(id=id, **example.dict())
+
+    for example in updated_points:
+      if example.id not in concept.data:
+        raise ValueError(f'Example with id "{example.id}" does not exist.')
+
+      # Remove the old example and make a new one with a new id to keep it functional.
+      concept.data.pop(example.id)
+      concept.data[example.id] = example.copy()
+
+    concept.version += 1
+
+    self._save(concept)
+
+    return concept
+
+  def _save(self, concept: Concept) -> None:
+    concept_json_path = _concept_json_path(self._get_base_dir(), concept.namespace,
+                                           concept.concept_name)
+    with open_file(concept_json_path, 'w') as f:
+      f.write(concept.json(exclude_none=True, indent=2, exclude_defaults=True))
+
+  @override
+  def remove(self, namespace: str, name: str, user: Optional[UserInfo] = None) -> None:
+    # If the user does not have access to the concept, return None.
+    acls = self.concept_acls(namespace, name, user=user)
+    if not acls.write:
+      raise ConceptAuthorizationException(
+        f'Concept "{namespace}/{name}" does not exist or user does not have access.')
+
+    concept_dir = get_concept_output_dir(self._get_base_dir(), namespace, name)
+
+    if not file_exists(concept_dir):
+      raise ValueError(f'Concept with namespace "{namespace}" and name "{name}" does not exist.')
+
+    shutil.rmtree(concept_dir, ignore_errors=True)
+
+  @override
+  def merge_draft(self,
+                  namespace: str,
+                  name: str,
+                  draft: DraftId,
+                  user: Optional[UserInfo] = None) -> Concept:
+    """Merge a draft concept."""
+    # If the user does not have access to the concept, return None.
+    acls = self.concept_acls(namespace, name, user=user)
+    if not acls.write:
+      raise ConceptAuthorizationException(
+        f'Concept "{namespace}/{name}" does not exist or user does not have access.')
+
+    concept = self.get(namespace, name, user=user)
+    if not concept:
+      raise ValueError(f'Concept with namespace "{namespace}" and name "{name}" does not exist.')
+
+    if draft == DRAFT_MAIN:
+      return concept
+
+    # Map the text of examples in main so we can remove them if they are duplicates.
+    main_text_ids: dict[Optional[str], str] = {
+      example.text: id for id, example in concept.data.items() if example.draft == DRAFT_MAIN
+    }
+
+    draft_examples: dict[str, Example] = {
+      id: example for id, example in concept.data.items() if example.draft == draft
+    }
+    for example in draft_examples.values():
+      example.draft = DRAFT_MAIN
+      # Remove duplicates in main.
+      main_text_id = main_text_ids.get(example.text)
+      if main_text_id:
+        del concept.data[main_text_id]
+
+    concept.version += 1
+
+    self._save(concept)
+
+    return concept
+
+
+def _info_from_concept(concept: Concept, acls: ConceptACL) -> ConceptInfo:
+  return ConceptInfo(
+    namespace=concept.namespace,
+    name=concept.concept_name,
+    description=concept.description,
+    type=SignalInputType.TEXT,
+    drafts=concept.drafts(),
+    tags=concept.tags,
+    acls=acls)
+
+
+# A singleton concept database.
+DISK_CONCEPT_DB = DiskConceptDB()
+DISK_CONCEPT_MODEL_DB = DiskConceptModelDB(DISK_CONCEPT_DB)

lilac/concepts/legal-termination/concept.json

@@ -0,0 +1,185 @@
+{
+  "namespace": "lilac",
+  "concept_name": "legal-termination",
+  "type": "text",
+  "tags": ["legal"],
+  "data": {
+    "731b1338cf1949958c3526c555f88058": {
+      "label": true,
+      "text": "In the event that any provision of this agreement is found to be unenforceable, the remaining provisions shall continue to be valid and binding.",
+      "id": "731b1338cf1949958c3526c555f88058"
+    },
+    "99a20e547e38474dbc24507a1658d0c9": {
+      "label": true,
+      "text": "The parties agree that in the event of a natural disaster or other unforeseen event, both parties will make reasonable efforts to fulfill their obligations under this contract.",
+      "id": "99a20e547e38474dbc24507a1658d0c9"
+    },
+    "3f27b47c526a4c5896a0a100024535c7": {
+      "label": true,
+      "text": "If any party breaches the terms of this agreement, the non-breaching party shall have the right to seek legal remedies.",
+      "id": "3f27b47c526a4c5896a0a100024535c7"
+    },
+    "d403dbb1ab9c4594bc7f7dcb0ad5b333": {
+      "label": true,
+      "text": "This lease agreement shall survive the termination or expiration of the lease term, and continue to be binding upon the parties.",
+      "id": "d403dbb1ab9c4594bc7f7dcb0ad5b333"
+    },
+    "b7deba9f7e80444abe14448f53f45c43": {
+      "label": true,
+      "text": "In the event of a dispute arising from this contract, the parties agree to first attempt to resolve the dispute through mediation before pursuing any legal action.",
+      "id": "b7deba9f7e80444abe14448f53f45c43"
+    },
+    "a82231b490174e62aad733cb0c75024d": {
+      "label": true,
+      "text": "This Agreement may be terminated, and the transactions contemplated hereby may be abandoned, at any time prior to the Effective Time, whether prior to or after the Company Stockholders' Approval:",
+      "id": "a82231b490174e62aad733cb0c75024d"
+    },
+    "160b25dbf14e4759a0065bbd652ce33f": {
+      "label": true,
+      "text": "This Agreement may be terminated and abandoned at any time prior to the Effective Time of the Merger, whether before or after the Company Stockholder Approval:",
+      "id": "160b25dbf14e4759a0065bbd652ce33f"
+    },
+    "8f5f9f96b16441228bb0c9b8a14c4e25": {
+      "label": false,
+      "text": "any jurisdiction, then such provision shall, as to such jurisdiction, be modified or restricted to the extent necessary to make such provision valid, binding and enforceable, or if such provision cannot be so modified or restricted, then such provision shall, as to such jurisdiction, be deemed to be excised from this Agreement; provided, however, that the legality, binding effect and",
+      "id": "8f5f9f96b16441228bb0c9b8a14c4e25"
+    },
+    "87b6c31b04a346b4a3e0da8d2cc5a7ac": {
+      "label": true,
+      "text": "This Agreement shall terminate automatically without any further action by any party hereto upon the earliest to occur of (a) the Effective Time of the Merger, (b) the termination of the Merger Agreement in accordance with its terms and (c) any amendment or other modification of the Merger Agreement that reduces the amount of the Merger Consideration or provides that the Merger Consideration shall",
+      "id": "87b6c31b04a346b4a3e0da8d2cc5a7ac"
+    },
+    "985344f7ecfb41f4a69ba101973221a1": {
+      "label": false,
+      "text": " During the Employment Period, the Corporation shall pay ----------- the Executive a base salary which, as of the commencement of the Employment Period, shall be at an annual rate of Two Hundred Fifty Thousand Dollars ($250,000). The base salary shall be payable in equal periodic installments which are not less frequent than the periodic installments in effect for salaries of other senior",
+      "id": "985344f7ecfb41f4a69ba101973221a1"
+    },
+    "5d53ff48376046fdab41e95c7f4bad54": {
+      "label": true,
+      "text": "This Agreement may be terminated at any time prior to the Closing Date solely:",
+      "id": "5d53ff48376046fdab41e95c7f4bad54"
+    },
+    "bdeb785be2154b21b4eb052466fa9bcb": {
+      "label": true,
+      "text": "(a) This Agreement may be terminated by you by notice to the Company at any time prior to the Closing Date if any of the following has occurred: (i) since the respective dates as of which information is given in the Registration Statement and the Prospectus, any material adverse change or any development involving a prospective material adverse change in or affecting the earnings, busi ness,",
+      "id": "bdeb785be2154b21b4eb052466fa9bcb"
+    },
+    "fe6871e9070441f8a9e4b3db26b077d7": {
+      "label": true,
+      "text": "Section 3(b), this Section 7 and Section 8 of this Agreement shall survive a termination of this Agreement pursuant to (a) or (b) above in this Section 7 until the date that is two years following the date of such termination. Notwithstanding anything else to the contrary contained herein or in the Merger Agreement, if the Effective Time occurs, the representations and warranties contained in",
+      "id": "fe6871e9070441f8a9e4b3db26b077d7"
+    },
+    "bf1a51751d0748e58c344aec8e5fc789": {
+      "label": false,
+      "text": "This Agreement may be executed in one or more counterparts (including counterparts executed and delivered by facsimile, which shall be as counterparts executed and delivered manually), all of which shall be considered one and the same agreement and shall become effective when one or more counterparts have been signed by each of the parties and delivered to the other party, it being understood that",
+      "id": "bf1a51751d0748e58c344aec8e5fc789"
+    },
+    "bc1b2affa6d848fd92d4dee033e30659": {
+      "label": false,
+      "text": "would, in your judgment, make it impracticable or inadvisable to market the Units or to enforce contracts for the sale of the Units, (iii) suspension of trading in securities generally on the New York Stock Exchange, the American Stock Exchange or the Nasdaq National Market or limitation on prices (other than limitations on hours or numbers of days of trading) for securities on any such Exchange,",
+      "id": "bc1b2affa6d848fd92d4dee033e30659"
+    },
+    "67a73d5887f74a91bed190ca8f64b17c": {
+      "label": false,
+      "text": " The authorized capital stock of FM consists of 1,000 shares of Common Stock, no par value each, of which 1,000 shares are issued and outstanding. There are no outstanding or authorized options, warrants, calls, subscriptions, rights (including any preemptive rights or rights of first refusal), agreements or commitments of any character obligating FM to issue any stock or any other Equity",
+      "id": "67a73d5887f74a91bed190ca8f64b17c"
+    },
+    "025b2ca5147849c8a921d9aaa31cd9cd": {
+      "label": false,
+      "text": "Taxes that are being contested in good faith by appropriate proceedings, provided that Holdings, the Borrower or Restricted Subsidiary, as the case may be, has set aside on its books adequate reserves therefor in accordance with GAAP.",
+      "id": "025b2ca5147849c8a921d9aaa31cd9cd"
+    },
+    "76acff27f13743f4822a094c707d8b75": {
+      "label": false,
+      "text": "have been a suspension or material limitation in trading in the Company\u2019s common stock on the New York Stock Exchange; (iii) there shall have been a general moratorium on commercial banking activities declared by either federal or New York state authorities or a material disruption in commercial banking or securities settlement or clearance services in the United States; (iv) there shall have been",
+      "id": "76acff27f13743f4822a094c707d8b75"
+    },
+    "b11a95c0eb564445b1a473e90622f861": {
+      "label": true,
+      "text": "10.1. This Agreement will terminate:",
+      "id": "b11a95c0eb564445b1a473e90622f861"
+    },
+    "d536428a02084d94ba18d412851cb913": {
+      "label": false,
+      "text": "may not be limited to his Base Salary and that the Employee may receive an annual bonus in the amount, if any, determined annually by the Employer. The Employee shall also participate in employee compensation and benefit plans available generally to executives of the Employer (including, without limitation, any tax-qualified profit sharing plan, nonqualified profit sharing plan, life insurance",
+      "id": "d536428a02084d94ba18d412851cb913"
+    },
+    "368bb1d9c7d0419d9ca58f28565eeb2e": {
+      "label": true,
+      "text": "This Agreement may be terminated in the absolute discretion of the Representatives, by notice to the Bank, if after execution and delivery of this Agreement and prior to the Closing Date (i) there has been, since the date of this Agreement or since the respective dates as of which information is given in the Registration Statement, the Time of Sale Information or the Prospectus, any material",
+      "id": "368bb1d9c7d0419d9ca58f28565eeb2e"
+    },
+    "1b5fd7b037a84404bf85c858953c79e8": {
+      "label": true,
+      "text": "however, (i) the right to terminate this Agreement under this Section 8 shall not be available to such Buyer if the failure of the transactions contemplated by this Agreement to have been consummated by such date is the result of such Buyer\u2019s breach of this Agreement and (ii) the abandonment of the sale and purchase of the Notes and the Warrants shall be applicable only to such Buyer providing",
+      "id": "1b5fd7b037a84404bf85c858953c79e8"
+    },
+    "6d5a23d2663f457cab96df03d9dc8ab7": {
+      "label": true,
+      "text": "In addition, any Stockholder may terminate this Agreement if Weatherford, WEUS, or the Company breaches any representation, warranty, covenant or other agreement contained in the Merger Agreement that (A) would give rise to the failure of Weatherford, WEUS, or the Company to satisfy any condition set forth in Section 8.2(a) thereof, and (B) cannot be or has not been cured within 45 days after the",
+      "id": "6d5a23d2663f457cab96df03d9dc8ab7"
+    },
+    "4a8223a48f83491b9b3eafd7ad37baf9": {
+      "label": true,
+      "text": "The obligations of the Underwriters hereunder may be terminated by the Representatives, in their absolute discretion, by notice given to and received by the Depositor or the Bank prior to delivery of and payment for the Notes if, prior to that time, any of the events described in Section 5(v) shall have occurred or any of the other conditions described in Section 5 shall not be satisfied.",
+      "id": "4a8223a48f83491b9b3eafd7ad37baf9"
+    },
+    "fbb152eae00c440bb2d0df0fbd82c262": {
+      "label": true,
+      "text": "Either of the parties hereto may terminate this Agreement by giving to the other party a notice in writing specifying the date of such termination, which shall be not less than 60 days after the date of receipt of such notice. In the event such notice is given by the Customer, it shall be accompanied by a copy of a resolution of the Board of Directors of the Customer, certified by its Secretary,",
+      "id": "fbb152eae00c440bb2d0df0fbd82c262"
+    },
+    "1d21880f426c45ada31409d22815cc87": {
+      "label": false,
+      "text": "Prospectus or the Final Prospectus (exclusive of any amendment or supplement thereof or thereto after the date hereof).",
+      "id": "1d21880f426c45ada31409d22815cc87"
+    },
+    "795cac72a3504740bc7401a84fc6fba4": {
+      "label": true,
+      "text": "This Agreement may be terminated by the Customer or the Bank by giving ninety (90) days written notice to the other, provided that such notice to the Bank shall specify the names of the persons to whom the Bank shall deliver the Assets in the Accounts. If notice of termination is given by the Bank, the Customer shall, within ninety (90) days following receipt of the notice, deliver to the Bank Instructions specifying the names of the persons to whom the Bank shall deliver the Assets.",
+      "id": "795cac72a3504740bc7401a84fc6fba4"
+    },
+    "3b82e6eba4894ac0b9f7f12aba2aab2e": {
+      "label": false,
+      "text": "of this Agreement, or to Authorized Persons, or may continue to hold the Assets until Instructions are provided to the Bank.",
+      "id": "3b82e6eba4894ac0b9f7f12aba2aab2e"
+    },
+    "da16bd0e9dce4d4c87400eab61b9b14c": {
+      "label": false,
+      "text": "into force of the Convention. In such event, the Convention shall cease to have effect:",
+      "id": "da16bd0e9dce4d4c87400eab61b9b14c"
+    },
+    "02cc328109984db094b0b02caec0d575": {
+      "label": true,
+      "text": "Survival.  The rights and obligations contained in Sections 3 (\u201cOwnership of Work Product\u201d), 4 (\u201cOther Rights\u201d), 5 (\u201cLicense to Preexisting IP\u201d), 6 (\u201cRepresentations and Warranties\u201d), 8 (\u201cConfidential Information\u201d) and 12 (\u201cNon-solicitation\u201d) will survive any termination or expiration of this Agreement. ",
+      "id": "02cc328109984db094b0b02caec0d575"
+    },
+    "f8edf65d9acf4ff4a04459a3492ac426": {
+      "label": false,
+      "text": "Severability.  Should any provisions of this Agreement be held by a court of law to be illegal, invalid or unenforceable, the legality, validity and enforceability of the remaining provisions of this Agreement will not be affected or impaired thereby. ",
+      "id": "f8edf65d9acf4ff4a04459a3492ac426"
+    },
+    "5a8517f359494ead8c11b6aff440480d": {
+      "label": false,
+      "text": "\u0095\tCommitted to deliver the best, we leave no room for customer grievances.\r\n\r\n",
+      "id": "5a8517f359494ead8c11b6aff440480d"
+    },
+    "a47d327d0f6e46fc861f86b2e0e54a2f": {
+      "label": false,
+      "text": "the due diligence and using our agreement creator to close the deal successfully. \r",
+      "id": "a47d327d0f6e46fc861f86b2e0e54a2f"
+    },
+    "811d0dcc92e14c5c881e903c7d4ff7b6": {
+      "label": false,
+      "text": "in accordance with customary procedures in the relevant markets, but in any event for a settlement period no longer than three months following the date of such commitment.",
+      "id": "811d0dcc92e14c5c881e903c7d4ff7b6"
+    },
+    "907f92e0d5704418944a559a4bfb96c7": {
+      "label": false,
+      "text": "terminate in accordance with Section 2 of the Investors\u2019 Rights Agreement.",
+      "id": "907f92e0d5704418944a559a4bfb96c7"
+    }
+  },
+  "version": 33,
+  "description": "Termination or survival clause in a legal document"
+}

lilac/concepts/negative-sentiment/concept.json

@@ -0,0 +1,634 @@
+{
+  "namespace": "lilac",
+  "concept_name": "negative-sentiment",
+  "type": "text",
+  "data": {
+    "0": {
+      "label": true,
+      "text": "Starting To Be Annoyed By Becky...: I'm not sure why I keep reading these books, but I guess it's because I've read the first two so I'll keep reading the rest of the books. In the first book, I really found it amusing. I was a little annoyed by the fact that Becky couldn't stop spending, but then again that's why she is called a Shopaholic. In the second book, I felt more of the same it was just magniifed more. Now in the third book, I'm just down right annoyed by Becky Bloomwood. In this book, she wasn't going on crazy shopping sprees, just planning two different weddings because she was afraid to tell each person and because I feel she's really selfish. Still, I read the book because I wanted to see how she could get herself out of another situation. I will say that I love her friends Suze and Danny, her client Laurel and her husband Luke. Maybe that's why I keep reading. I will read the next book, but I'm sure I'll be just as annoyed when I'm done.",
+      "id": "0"
+    },
+    "1": {
+      "label": true,
+      "text": "the cover is fine - the pool is horrible: The entire pool was horrible. The cover was fine once we got it on, but we finally got rid of the pool after 2 weeks because it was so hard to set up and keep clean.",
+      "id": "1"
+    },
+    "2": {
+      "label": false,
+      "text": "Good album, not their best.: This album is probably the most marketable and radio friendly of all of dashboard's albums. For the peripheral listener it may be the right one to get to introduce you to this band. But as a Dashboard fan of 5 or so years I truly hope they return to their original sound for their next work. Not for the listen-ability but for the show. To this day the fans react best to the songs from \"Places\" or \"A Mark, A Mission.\" I recommend this album to everyone but I also recommend any and all of their other work.",
+      "id": "2"
+    },
+    "3": {
+      "label": true,
+      "text": "This is a horror novel, right?: Never one to pass up any vampire novel, I purchased Sips because the description seemed interesting. Vampires, Marquis de Sade, fetishism, yada yada yada. If this is a comedy, I give it 4 stars; however, I'll give it 1 star as a horror novel. Sade was rather boring; I would think a character as intense and multi-faceted as the Marquis de Sade would make for a more interesting vampire. The writing style isn't too bad, but overall I found the characters to be mildly amusing at best. The plot was thin, the end was anti-climactic, and the vampires were not very frightening. The book had little suspense, and it leaves a mile-wide opening for a sequel at the conclusion. I would, however, like to see something more of the vampire mutants lurking in the graveyard. They were the most riveting of any of the characters.",
+      "id": "3"
+    },
+    "4": {
+      "label": false,
+      "text": "Superb mix of global non secular musical denominations: I first heard Ms. Pook's music on the \"Eyes Wide Shut\" soundtrack (the masquerade ball scene) and was blown away; if ever there was a necessity for music to permeate a scene in a film this was it. She incorporates a blend of the traditional songs from faiths across continents and mixes them, for lack of a better comparison than similar to your quintessential raver d.j. (though these are better and definitively more original :) \"Oppenheimer\" is my favorite, and if you let the last track run for a few minutes a portion of the song will play once more. I can't wait to hear more of her stuff - these hymns are awesome.",
+      "id": "4"
+    },
+    "5": {
+      "label": false,
+      "text": "A moving and suspenseful story!: For anyone familiar with the occult, this book is likely to raise hairs on the back of your neck as you read. Even if you're not, the storyline is suspenseful and fascinating, and the characters evoke great sympathy and admiration. An excellent read.",
+      "id": "5"
+    },
+    "6": {
+      "label": false,
+      "text": "Simple & Easy to Use - A Practical approach to eating out: This guide is extremely to use. It provides sample menus that you'd see at Chinese, Indian and Thai restaurants. Then you are provided with descriptions of each dish and how it is prepared and the ingredients used. From there you are provided with specific considerations as to how the preparation or ingredient list may affect you if you have Gluten or Allergen issues.This book is the size of a passport and very organized and well written. The Chinese, Indian and Thai Cuisine Passport is perfect for making choices while traveling, or while dining at your favorite local restaurant.",
+      "id": "6"
+    },
+    "7": {
+      "label": true,
+      "text": "Being Fair....I am a fan of hers: and I really enjoyed her previous works, more than I could have ever imagined, but this record is horrible. The songs are trite, the lyrics are incredibly boring, indulgent and immature. The music is pop staple, with forgetable melodies and repetative chorus lines, I feel as if the studio wrote the entire album for her while she was sleeping, this just doesn't speak to any of her previous works at all. This album fits on the same shelf with a Nickelodeon-themed CD. Instead of heading in the direction of an artist like Alanis Morrisette, she is going backward and joining the ranks of Hannah Montana and the Naked Brothers Band. She is a great artist and her first two records are amazing. She is better than this CD and I am looking forward to her next effort.",
+      "id": "7"
+    },
+    "8": {
+      "label": true,
+      "text": "Sucked: I thought the DVD sucked tremendously. It was very boring and if I could, I would return it for a refund. There was only one \"small\" clip of Dylan himself. I'm very disappointed.",
+      "id": "8"
+    },
+    "9": {
+      "label": false,
+      "text": "Excellent product: Easy to install. If you have a newer furnace you probably do not need the swail switch as the HE220A comes with a Humistat which can be connected to the furnace. They recommend the Honeywell 32005847-001 Installation Kit, Bypass which is a little pricey and you can probably buy the pieces of this kit cheaper individually from Home Depot or Lowes or ACO as well as the filters.",
+      "id": "9"
+    },
+    "10": {
+      "label": false,
+      "text": "Very happy.: I am very happy with this trashcan. I was unable to find one in the stores to fit the space in my cabinet, but this one does the job. It is very sturdy and looks like it will put up with years of use.",
+      "id": "10"
+    },
+    "11": {
+      "label": true,
+      "text": "These aren't Throughbreds!: This makes me so mad. All these new authors are coming and changing the series. Nothings the same anymore and the plots are repeditive. Don't even bother reading these books until #32 these are like a different series. I don't know excactly what's happing but these new authors suck!",
+      "id": "11"
+    },
+    "12": {
+      "label": true,
+      "text": "Large and slow are a bad combination.: I bought this TV and returned it a week later, because it blurred so badly with motion that sports were unwatchable. I ended up buying a smaller Sony XBR4, and I have none of the issues (plus the picture is far, far better).This has nothing to do with 60 vs 120Hz. That is more important for DVDs and Blu-Ray signals that are 24fps (which doesn't divide evenly into 60 but does for 120). The LT52133 has an 8ms response time, which is extremely slow. A decent LCD should be 5 or lower.If you want an LCD, choose speed and quality over size. If you want size and quality but want to spend less, buy a plasma. Don't buy a big, cheap, slow LCD!I gave it 2 stars because I like the interface and remote.",
+      "id": "12"
+    },
+    "13": {
+      "label": true,
+      "text": "Skip it: This movie is very poorly written and the result is not distressing, just lame. The actors do their best but from very early on it is obvious that the material gives them nothing to work with. Fans of Colin Firth will experience a certain dim level of enjoyment. Minnie Driver is a treat but her character is no better written than the others. Vermont locations are worth something. With one or two moments of exception it's neither comedic nor romantic.",
+      "id": "13"
+    },
+    "14": {
+      "label": false,
+      "text": "Belive it i went to the concert?: hi everyone let me tell you i went to the concert i was amazed with what i saw cher was awsome i tell you buy the dvd. as i sat in front of the stage cher was doing a great job to us the she is living proof . So i urge you to buy it?",
+      "id": "14"
+    },
+    "15": {
+      "label": false,
+      "text": "Vale la pena.: En este libro se narra de una forma muy interesante la vida de una familia en particular. Lo que mas me gusto de este libro fue la manera en que la autora describe a lo largo del libro las personalidades de los sujetos envueltos en la novela; que vienen a ser muy distintos y extremos, lo cual, intensifica el drama... Definitivamente es un buen libro y lo recomiendo a todos.",
+      "id": "15"
+    },
+    "16": {
+      "label": false,
+      "text": "Nummie Children's story: I ordered this book for our grandchildren. Two boys 5 & 3 and a 4 month old girl. All love the story. The mouse is determined.",
+      "id": "16"
+    },
+    "17": {
+      "label": true,
+      "text": "Seem to be alone on this one: Looking at the other reviews, I seem to be the only one that was disappointed with this book. The content is too babyish in most of it for older tweens and the more \"grown up\" content would be over a younger tween's head. I had a quick read through and with every paged turned, I thought duh. I'll be looking around for another book shortly.",
+      "id": "17"
+    },
+    "18": {
+      "label": false,
+      "text": "Best yet: by far the best EA game yet. I especially like the easy controls and kick - a graphics. the playbook is extremely accurate and detailed. Also the fight songs and cheerleaders were a nice touch. this is an excellent game and worth checking out.",
+      "id": "18"
+    },
+    "19": {
+      "label": true,
+      "text": "washed out: A bit like Simply Reds version of the Valentine bros hit \"Moneys too tight to mention\" - this cover version has nothing of the driving energy that characterised the original recording.",
+      "id": "19"
+    },
+    "20": {
+      "label": false,
+      "text": "great water bottle: I love this bottle it is great. I like knowing it is non toxic and it just works very well. You can have it full and lay it down and it doesn't leak at all.",
+      "id": "20"
+    },
+    "21": {
+      "label": false,
+      "text": "Nice goggles: I am pretty happy with these goggles. They work well during swim workouts in the pool. I do notice a little bit of fogging from time to time. I had hoped to wear them during an upcoming triathlon, but based on a few instances where they slipped a little in the pool I am concerned that they won't be secure enough. I will keep using them in the pool, but will likely get different ones for open water races.",
+      "id": "21"
+    },
+    "22": {
+      "label": true,
+      "text": "aaahhh nnnoooooo!: Hopefully the last film in one of the worst horror trilogys ever made. This series pretty much ruined the horror film for years to come, for one its too self aware, thats incredibley annoying, second everyone acts like they are on Friends or some sitcom. The acting is just plain bad and unconvincing. Now the gore, if you're going with material this weak you should load it up with disgusting violence, is there any in the Scream series? No.Everyone went to see this movie just to see who THE KILLER is. This movie sets low standards to be met, you expect alot of people to die, one shock, then we find out who the killer is, then you go home. Every horror film being made today is like that, there's nothing new or exciting or risk taking, its the same stuff over and over and people are laping it up like dog food.This film is what you've come to expect, bad acting, some people die and we eventually find out who the killer is and all is merry and well. Pathetic.",
+      "id": "22"
+    },
+    "23": {
+      "label": false,
+      "text": "A classic of its kind: This movie is a classic of its kind and much better that a lot of movies, that followed. It is not one of the best, but it still deserves five stars...",
+      "id": "23"
+    },
+    "24": {
+      "label": true,
+      "text": "Nice suite, but Virtual PC 7 disappoints on my G5: I purchased the upgrade since I'd already bought both Office v.X and Virtual PC 6.1 last year.The biggest letdown is that Microsoft's promised support for the G5 is nearly non-existent. I have a dual processor G5 with an ATI Radeon 9800 card (Apple), and after trying to install Virtual PC 7 three times, I cannot get a VM to work. It did install (and work) flawlessly on my G4 Powerbook. Googling for reviews finds it's very hit or miss, but if (when) it misses, you'll regret investing the extra $$$ in an immature product.",
+      "id": "24"
+    },
+    "25": {
+      "label": true,
+      "text": "Okay player, don't expect a miracle: I bought this DVD player at Circuit City earlier this yr for about a $100. I hooked it up to a 47\" Vizio LCD (which by the way has an awesome picture) using a HDMI cable. After fine tuning this product, I was very, very, very diasppointed. The picture was very \"grainy\" (lots of pixels). I have a $35 DVD player that only utilizes an s-video cable that produces a much more crisp picture. Be warned, the picture stinks.",
+      "id": "25"
+    },
+    "26": {
+      "label": false,
+      "text": "A revelation of the science of consciousness evolution and all natural growth: Here is a readable and fascinating account of the development of the new science of chaos theory, the only body of ideas that describes how the natural world as experienced by human beings emerges out of basic quantum processes. The different explorers and innovators of the new science are introduced in a personable way that will enchant the interested reader.",
+      "id": "26"
+    },
+    "27": {
+      "label": true,
+      "text": "Don't say that I didn't warn ya' !: I'm absolutely convinced that Delbert McClinton had no controlover the release of this CD. I rated it 1 star simplybecause there is no 0 star rating ! In actuality , I am not certain that the vocalist on this recording IS Delbert McClinton. Only on the Mr. Pitiful track is there any similarity at all to Delbert's voice. This is the perfect CD for someone with money to burn who would like to have a recording of a 1960's garage band recorded in a garage and who should be working in a garage ! Delbert fans...run fast and run far away from this ! END",
+      "id": "27"
+    },
+    "28": {
+      "label": true,
+      "text": "This item is not available: I ordered this unit on February 7th. Every time I checked back on the status of the order, it read \"not shipped\" and the estimated shipping date got moved out. I really don't think this unit is avaialble from the company anytime soon. I cancelled the order.",
+      "id": "28"
+    },
+    "29": {
+      "label": true,
+      "text": "I used to like ABBA...: I used to like ABBA, until I saw Mama Mia! A horribly disjointed musical, where songs feel contrived to fit into the story; a story that doesn't seem to come together. Individual songs are usually done alright, but don't segue from one to another very well.The cast butchered several of the songs, but especially S.O.S, Take A Chance On Me, and anything where Pierce Brosnan sang. On a side note, I also counted at least two violations of Chekov's Gun. And finally, I think it has a bad moral message. Which you only recognize if you manage to sit through the whole thing.If there is justice in the world, cast members without established careers won't get to have them as punishment for the worst movies I've seen since The Talented Mr. Ripley.",
+      "id": "29"
+    },
+    "30": {
+      "label": true,
+      "text": "A complete disaster!: If you're like me, you probably wanted to check out this movie because it sounded like it really could be an excellent supernatural Gothic horror tale full of goblins and wicked things alike. Well, don't make the same mistake I did and actually watch it. It's horrible. Terrible. An honest to goodness waste of film. The acting is wretched, the film quality is rotten (it actually looks twenty years older than it is), and the plot is thin, weak, and does not give you what it's supposed to. The only reason I bothered to give this film 1 star is because of Alexis Arquette -- he's great looking, but should have left this film out of his career.",
+      "id": "30"
+    },
+    "31": {
+      "label": false,
+      "text": "beautiful detail: I just purchased these Dover COloring Books for my mother and she loves them. The detail is out of this world and the variety of colors you can use are only limited by your inagination. HIGHLY RECOMMENDED!",
+      "id": "31"
+    },
+    "32": {
+      "label": true,
+      "text": "Very disappointed: I looked forward to getting this movie as I had heard many good things about it but it was nothing like I had imagined or been led to believe. There is very little actual history in it or real Christian experience except for the background because the main focus is a soap opera style romance and caricature figures. I agree with the reviewer who described it as a mixture of \"tawdry Hollywood sex\" somehow interspersed with a vague nod to Christianity. The only decent scene was the arena scene where the Christians are going to their deaths singing hymns - but that's not enough to make it a great or even a good movie. Not personally to my taste anyway.",
+      "id": "32"
+    },
+    "33": {
+      "label": true,
+      "text": "Unreliable minikit: I bought this minikit because it got good reviews and it would be perfect for my purposes. However it switches on and off whenever it wants, it looses contact with the phone. Very often the on/off button works only in a horizontal position (?) I use a Treo 650, which is on the compatible phone list. When I contacted Parrot, they said it wasn't (?) At last I opened the unit, but there are no moving parts inside except the micro switches. It is giving me a headache, so I will go searching for an alternative.",
+      "id": "33"
+    },
+    "34": {
+      "label": false,
+      "text": "A Christmas Classic!: This is surely one of the best classical Christmas recordings available. Don't buy the older version, as the quality of this recording is excellent. This is one of those \"Every Christmas - Can't have Christmas without\" recordings.",
+      "id": "34"
+    },
+    "35": {
+      "label": true,
+      "text": "too narrow: These were the narrowest pair of D size shoes I have ever tried on. I don't care how nice a shoe looks. If it don't fit it just don't fit.",
+      "id": "35"
+    },
+    "36": {
+      "label": true,
+      "text": "Lack of extension: This earphones lack a descent extension cord. ITs very small cable, but its of good quality. Sadly, cord its too short, and the extension is useless.",
+      "id": "36"
+    },
+    "37": {
+      "label": false,
+      "text": "Easy-Reading: This is the 3rd Southern Sisters Mystery I've read. They're easy, fast and funny murder mysteries, with lots of cute family stories intertwined in the intrigue.",
+      "id": "37"
+    },
+    "38": {
+      "label": true,
+      "text": "it'd be great if it worked like it was supposed to: for the first 30 seconds it was lovely, but i believe that either the motor isn't powerful enough to keep the shaft rotating smoothly or 3 AA batteries just don't provide enough juice for the motor to work more than 30 seconds. it was a nice idea, but i'm rather dissapointed. the jelly material is somewhat difficult to maintain also. i think if it were hooked up to a larger battery pack it'd be WONDERFUL... which i think i may have a macgyver friend with a knack for electronics attempt to do for me.",
+      "id": "38"
+    },
+    "39": {
+      "label": false,
+      "text": "Not Hornby's best but still good: I loved About a Boy and really, really loved the sardonic wit of High Fidelity. About a Boy is much deeper but just as cynical. Maybe even more so. The characters are richly drawn and just complex enough to keep the reader wanting more. Good read, but best to take some time with this one. Not recommended for a summer beach read.",
+      "id": "39"
+    },
+    "40": {
+      "label": true,
+      "text": "A Disappointment: As with most Taunton Press publications, the illustrations and photographs in this book are spectacular and the organization and layout is superb. Nonetheless, I found this book disappointing. It lacks both depth and breadth. I had hoped for a detailed review of wood joinery including some of the more unusual joinery found in Japanese woodworking. This book, however, is targeted more toward the beginner. Even so, it does not cover the details and \"tricks\" of even the most basic techniques in sufficient detail to allow beginners to easily reproduce them. Consequently, it is unclear who this book was written for - not the beginner as it lacks depth, and not the advanced woodworker as it lacks breadth. Far more effort appears to have been put into appearance and organization than in content.",
+      "id": "40"
+    },
+    "41": {
+      "label": true,
+      "text": "Horrible. Don't do it!: Great price for the item when a 6' one of these at Best Buy is $20. Thing is, the one from Best Buy fits in the outlet and stays there. This cord fits very loose and does not connect. I bought 2 of them, neither did what they were suppose to.As much as I hate to say it, but, buy the more expensive one. At least it works.",
+      "id": "41"
+    },
+    "42": {
+      "label": false,
+      "text": "Given as a gift...: Given to my best friend as a gift. She loves it. Her fiance enjoys making coffee for her in the mornings. :)",
+      "id": "42"
+    },
+    "43": {
+      "label": false,
+      "text": "Love the ring.: This is a nice ring. I was worried it out be thin and cheap looking, but it's not. It's a very pretty stylish ring. Go for it.",
+      "id": "43"
+    },
+    "44": {
+      "label": true,
+      "text": "Beautiful writing Marred by One-Note Characterizations: How could Kingsolver have ruined her book with such an obvious error? Nathan is a strident paper doll that flattens the whole story. Just as bad, the author has all the narrators using the same ironic tone to decribe him, deadening their voices as well. At the same time, Kingsolver doesn't have the guts to show him doing something trully terrible. I don't trust an author who can't let the reader make up his own mind, and as a consequence I couldn't trust her views about ANYTHING in the story. I'm giving this two stars for her descriptions of the African landscape, and that is all.",
+      "id": "44"
+    },
+    "45": {
+      "label": true,
+      "text": "Much worse than any cordless phone I've ever had: This phone cuts out only 2 rooms away from the base station. There is static noise, and callers on the other end complain about sound quality. I can't go into the garden, which used to be no problem with my old 900 MHz phone.",
+      "id": "45"
+    },
+    "46": {
+      "label": true,
+      "text": "Waste of time & money: The first Hangover was not too bad, this one was just terrible. The acting is bad, the script is bad, everything about this movie was just bad. Do yourself a favor, don't buy this movie as it is a total waste of time and money.",
+      "id": "46"
+    },
+    "47": {
+      "label": true,
+      "text": "Did Not Work For Me!: Impressive You Tube Video (Like a Sci-Fi Fantasy). In reality it's a high speed Easy Out so unsurprisingly it broke faster than an Easy out. This product did not work for me. The drill part did not drlil, the puller part did not pull. It was a total zero.",
+      "id": "47"
+    },
+    "48": {
+      "label": false,
+      "text": "Excellent book, long overdue.: From a very long time women were told that looking good was of utmost importance. This was without regard to health or fitness and how age affected these parameters. Witness the whalebone and other types of corsets, the spike heeled shoes and the numerous weight loss programmes on the market (some of which are downright dangerous). Now there is a book, backed by solid research, that allows women of all ages to remain fit and healthy for a lifetime. I am certainly going to recommend this book to all the women I know.Bentley Norville",
+      "id": "48"
+    },
+    "49": {
+      "label": true,
+      "text": "not an all star: Not a practical guide in this collecting age. Does NOT have a comprehensive list; meaning it does NOT cover all manufacturers and, more importantly, for the ones it does, only provides listings of the base set. That means no insert or variation pricing whatsoever. Also, no oddball or minor league issues are listed. Generally speaking, unless you are collecting base sets prior to the advent of inserts and alternate versions of the base set, this guide is fairly useless.",
+      "id": "49"
+    },
+    "50": {
+      "label": true,
+      "text": "Again, second rate city, third rate writer: Just another example of Mr. Lindberg's pitiful attempt at exhibiting a strong expertise on a subject with which he is clearly obsessed. Don't waste your time with this book, either. It is poorly written and fails to engage the reader. You might consider using this book and the first book he wrote on the same subject, as a pair of bookends. That is about all they are worth.",
+      "id": "50"
+    },
+    "51": {
+      "label": false,
+      "text": "Reality: No one should need to convince you to buy this book, you should just do it! It's so well written and worded and brings you right to the heart of a sexual reality that most people like to pretend doesn't really live and breath in their fair cities. I never again want to hear someone bad mouth a working girl for what she does. I will and do now however look at men with a curious eye wondering if they are depraved peep show window lickers :)",
+      "id": "51"
+    },
+    "52": {
+      "label": true,
+      "text": "Bummer: Visual effects and Battle footage were great...the other 85% of the movie was just lousy fluff...",
+      "id": "52"
+    },
+    "53": {
+      "label": false,
+      "text": "The spark of idependence: Filled with the independent spark that made us all love life at one point or another. A fun, introspective and nonsensical movie that sticks with you.",
+      "id": "53"
+    },
+    "54": {
+      "label": false,
+      "text": "What I expected from Mirman's website. Funny. Funny. Russian.: lol, gotta love Eugene. Even when his audience doesn't initially laugh, he gets in a good zinger at himself and they laugh at that. He's witty without being condescending, and uncomplicated without seeing contrived. However, if you're not a fan of irreverant humor, this may not be for you.",
+      "id": "54"
+    },
+    "55": {
+      "label": true,
+      "text": "Do not...repeat...do not bother!: It is not often that I offer a negative review but this compilation while attractive does not deliver at all.The foot massage gizmo is awkward and uncomfortable.The pumice stone leaves rough splinter like skin.The foot scrub doesn't reall scrub.The rotary action tool has five heads, none of which work well and you must hold the switch in place or it turns off. It is cumbersome and ineffective.The one star was initially given for a foot brush (which later lost its bristles very easily as I update the review) and a sweet smelling foot repair balm.Don't waist your money. Soak your feet and invest in an inexpensive German Titania file, smooth and coarser side, or a like product. It will last for years.",
+      "id": "55"
+    },
+    "56": {
+      "label": true,
+      "text": "Not Sandra's Best: Ms. Brown has written better romance novels. Don't give up on her if this was your first Sandra book.The feeble female lead struggles with a 15-year crush that walks back into her life. The smug male lead acts like a jerk through most of the novel. The romance scenes grapple to muster up passion but fall short. Both of the main characters bothered me; my favorite character was the 17-year old.A quick read...about 4 hours (with interruptions) for me...but probably not worth it.",
+      "id": "56"
+    },
+    "57": {
+      "label": false,
+      "text": "Impressed: Lots-O-Fun. Wood and glass toys are high quality and are a good fall back for the kids to play with they are \"bored\". Would buy again.",
+      "id": "57"
+    },
+    "58": {
+      "label": true,
+      "text": "Light turned on by itself 3 times: The installation was easy. I used it for a week, everything worked fine, EXCEPT the light it connected to turned on by itself 3 times so far, with no one near to either one of the switch. Not sure whether it is a defective unit, or this product is too sensitive to noise. I'm returning this product and will just install a regular switch instead.",
+      "id": "58"
+    },
+    "59": {
+      "label": false,
+      "text": "good battery: I feel kind of silly writing a review for a battery, but have to say that these last a LONG time. Work very well.",
+      "id": "59"
+    },
+    "60": {
+      "label": false,
+      "text": "Even a Woman finds it funny: Yes, even a woman finds \"Married to Mommy\" funny. The book gets you laughing aloud when it is trying to make fun of \"Mommies\". The truth is that it really is making fun of the stupidity of men and their simple basic needs of sex, getting out of work, and beer. Of course, the truth is always funny.A definite MUST for any woman, married or not. We will now know all the secret tricks the men try to use on us.By the way, I am NOT a MOMMY!",
+      "id": "60"
+    },
+    "61": {
+      "label": false,
+      "text": "Gungrave...not quite what you might expect: Those thinking this is another version of Trigun will be disappointed. Gungrave is actually a lot deeper and more complex. The lead is short on dialouge, but the story has more depth and character development than most anime. The first DVD is more about the main character's past than about the reanimated killing machine he's become, but it definitely leaves you wanting more.",
+      "id": "61"
+    },
+    "62": {
+      "label": false,
+      "text": "Error in product description: It's great in every way. However, if you'd prefer a digital tuner (as I do), then you might need to look further. The product description boasts a digital AM/FM tuner, but it's disappointingly an analog AM/FM tuner.Overall - especially for the price - I think it's pretty good.",
+      "id": "62"
+    },
+    "63": {
+      "label": false,
+      "text": "good phone but not as user friendly as it could be: Battery life is very good. Phone has good range. My only complaint is it's to involved to get your message from the handset.",
+      "id": "63"
+    },
+    "64": {
+      "label": true,
+      "text": "Big waste of money (and space in my house!): My 5 year old son wanted this so bad, but when we got it for him, there were so many pieces to put together that didn't fit together well, he never played with it. It just sits on our floor in many pieces taking up toy space! What a waste!",
+      "id": "64"
+    },
+    "65": {
+      "label": false,
+      "text": "Don't want to take it off: Very satisfied with an earlier purchase of this Bali bra model, I was just as pleased with the new one. Very comfortable, well made and a good neutral color. It will be my next choice, too.",
+      "id": "65"
+    },
+    "66": {
+      "label": false,
+      "text": "Fantastico: If anybody who's into rock music is ever looking for a band to keep you on your toes, this is the band. I've been a fan for 10 years now, and no album has ever sounded like any of their previous albums. This disc is fantastic with such a variety of styles, as are the previous releases, even back to the Rainbow Butt Monkey days.",
+      "id": "66"
+    },
+    "67": {
+      "label": true,
+      "text": "too much visual: There are far too much designs, visuals, colors, etc in the book - this is highly distracting, as TV screen can be...By way of example (among so many...), what is the use of colors with the three squares of the Pyth. theorem???? this is as useless as writting 2+3=5 with 2 in blue, 3 in red and 5 in yellow...I wish I had purchased the 2nd edition, which according to reviews was closer to what I was looking for.",
+      "id": "67"
+    },
+    "68": {
+      "label": false,
+      "text": "Aretha's First Arista Release Showed Pleasures to Come: After a long and musically satisfying career with Atlantic, Aretha severed her ties with that company and moved under the wing of Arista's Clive Davis. With the start of the 1980's, Aretha was looking for new territory to conquer and almost succeeded with this mixed bag.\"United Together\" is a fine tune that benefits from beautiful orchestral arrangement that is matched by Aretha's superb vocal instrument. The remake of \"Can't Turn You Loose\" allows Aretha to show why she is the Queen of Soul\" for she really belts this one out. Another cover, that of the Doobies' \"What a Fool Believes,\" is an interesting interpretation. The final cut \"School Days\" appears to be \"autobiographical\" for every girl growing up in the fifties.Although not as strong as her Atlantic work, \"Aretha\" is still a suitable addition to the artist's discography.",
+      "id": "68"
+    },
+    "69": {
+      "label": true,
+      "text": "Misguided Purchase: The photo and description do not reflect the product. The screen panel kit I received was white. What a huge inconvenience during a time-crunch.",
+      "id": "69"
+    },
+    "70": {
+      "label": true,
+      "text": "Banacek: My husband and were looking forward to seeing this series.The first show was SO boring, we finally just quit watching it.Actually, we haven't gotten around to watching anymore. I guess we were afraid of a repeat.Maybe that was just once, I hope!",
+      "id": "70"
+    },
+    "71": {
+      "label": false,
+      "text": "JDT: Uncle Tupelo is without doubt one of the most under appreciated groups of the 90's. Anodyne, like each of the three albums that came before it, has everything that a remarkable recording requires: great songs, honest lyrics, and artists who really care about the music they are making. Like the best of Dylan and Springsteen, the songs are about real people with real troubles and joys. When you hear them you know they are coming from the heart. The songs contributed by Jay Farrar and Jeff Tweedy are easily differentiated by the voacls, music, and lyrics. What makes this record interesting is how well these unique sounds compliment each other. The union is seamless.",
+      "id": "71"
+    },
+    "72": {
+      "label": false,
+      "text": "Well Worth Reading: First a confession: Miriam Wasserman was my mother. However, she published several books, but this is the only one I really found useful. She walks the reader through the New York City school system and the attitudes of different groups involved in the system back in the 1960s. This includes parents, teachers and administrators. Her view is that the further away one got from parents and students, the more prestige one had. She meticulously describes the teachers' strike of 1968 against \"community control of schools\", a strike of which she is extremely critical. She explores the racism that was involved in this strike, including using quotes from striking teachers, etc. It should be emphasized that the author was pro-union all her life, so her views don't stem from an anti-union bias. The book also covers the high school student rebellion which coincided with and followed the strike.",
+      "id": "72"
+    },
+    "73": {
+      "label": false,
+      "text": "compact and loaded: I bought this phone after reading the cnet reviews and really liked it. It looks small and really compact. I like the camera pics at 2 mega pixel and bright flash. The mp3 player is crisp. The headset that comes along delvers amazing fM radio. I think my phone is not very loud and you have a problem when you are around a noisy crowd. I just bought this phone again for my cousin. He likes it too. Almost forgot the display is very good.",
+      "id": "73"
+    },
+    "74": {
+      "label": false,
+      "text": "Outstanding text!: Brooks/Cole should keep this text in their catalog for ages! It is well-written, examples are generally quite clear, vocabulary is introduced well, and the exercises develop real skills, rather than simply be busy-work. One of the best calculus books ever!",
+      "id": "74"
+    },
+    "75": {
+      "label": false,
+      "text": "Excel 2003 Bible: Very good source of information. I will most likely buy other books in this series.",
+      "id": "75"
+    },
+    "76": {
+      "label": false,
+      "text": "Tasting is Believing: Gluten-free breads used to have a gritty texture from the rice flour, and were too soft for sandwiches. Bette Hagman uses garbanzo/fava bean flour, sorghum flour, tapioca flour, and corn starch to create breads which have a similar texture to wheat flour breads, and the flavors of her breads are fabulous.My BF bought me this book and a great tasting beverage to drink it with. Since he knows I quit coffee recently, he's been really wonderful helping me in cope with my mood swings. S o y f e e is made from soy beans that is roasted just like coffee. I enjoy the taste and don't miss coffee one bit. Buy it online at www.s o y c o f fee.com.This is a 'must have' for anyone baking gluten-free. I think all of Bette Hagman's books are wonderful and a must for those with gluten intolerance.",
+      "id": "76"
+    },
+    "77": {
+      "label": false,
+      "text": "5 stars for the show, no stars for the \"Collector's Edition\": I was really looking forward to getting this Collector's Edition and see what extras were added. I knew it wasn't a lot - just a mini-book and a documentary - but I figured it would be packaged in a cool way.Wrong.As others have already mentioned, the Collector's Edition is *literally* theAvatar: The Last Airbender - The Complete Book 1 Collectionslipped into another cardboard box, with a little booklet and DVD in an envelope (not even a case!) wedged in. It's really disappointing; it would have been so easy to create a quality Collector's Edition but the studio couldn't be bothered, I guess.",
+      "id": "77"
+    },
+    "78": {
+      "label": false,
+      "text": "sula scottcampos: Sula, a book that talks about the issues of being a black women is a really good novel to read.One of the reasons I recommend it is because of its realism and its themes - death, sex, friendship and poverty.I also think that its characters are very good, its easy to identify with one or both of them. I really recommend this book to anyone who enjoys good literature.",
+      "id": "78"
+    },
+    "79": {
+      "label": false,
+      "text": "Fantastic! It's a must-have for girls!: I hated razor, tried shaving but it did not work for me. Shaving made the hair grows thicker and faster afterwards, plus the roots are impossible to be getting rid of. After reading the reviews, I ordered it to try, I used it for once and already fall in love with this. I used to use small tweezer to pluck out my leg's hair, in order to avoid the razor, it took me a few hours to do that but this super electronic tweezer works wonder! You won't see the black roots and I have smooth and silkly legs in 20 mins. It does not hurt at all, if you use it on your legs. But, if you use it at your under arm, it won't be a pleasant feeling, of course! I will never use anything else besides this for hair removing anymore! highly recommended!",
+      "id": "79"
+    },
+    "80": {
+      "label": true,
+      "text": "This is not a toy: I guess I was expecting more out of these leave window decals. I just didn't find them attractive after placing them on my window, they seem very cheap, I guess because they are cheap.I threw them away.",
+      "id": "80"
+    },
+    "81": {
+      "label": false,
+      "text": "Wonderful book for anyone running a professional hatchery: This book is aimed more for hatcheries that are raising Trout, Salmon, Catfish and other food fishes. However, there is so much information in this book that even ornamental fish hatcheries will find an incredible amount of useful information. The chapters on Fish Nutrition are especially helpful.",
+      "id": "81"
+    },
+    "82": {
+      "label": false,
+      "text": "Amazing book!!: Once again, Eric Victorino's artistic talent is put into this great free-verse poetry book. I couldn't put it down and I finished it the day I received it in the mail. All of the poems are awesome but the one I found the most interesting was \"It's A People Business.\" All of the experiences in his life, personally and with his band, come to life in this book. Please check it out! It's worth every penny!!",
+      "id": "82"
+    },
+    "83": {
+      "label": false,
+      "text": "The white trumpet contender respect Miles Davis!: The story of the Jazz in the Fifties certainly would be remain unfinished without the ominous presence of this outstanding virtuoso. Baker sound still possesses this alluring hook, this magnetic engagement charm, eloquent expressiveness, enrapturing lyricism and contagious rhythm, despite the elapsed time, which confirms by itself the status of his musicianship.This selection is jus a little sample of the broad universe of his genius. A well thought selection of great musical successes, available, preserved and immortalized by the Digital Technology for our future enjoyment.Absolutely indispensable in your treasured collection.",
+      "id": "83"
+    },
+    "84": {
+      "label": true,
+      "text": "What the?: I'm sorry, maybe it's just me but I can't helping stating that this has to be one of the wrost movies I've seen in my life!Can you say boring? Can you say doesn't make sense at all? The first 30 minutes of the movie were O.K. But it went downhill after that. This movie is a prime example of a director attempting to make a deep movie with a meaningful lesson but failed on all levels. I don't recommend this movie unless you want to go to sleep or you don't have anything else to do.",
+      "id": "84"
+    },
+    "85": {
+      "label": false,
+      "text": "very very good!!!!: linda blair is a young girl who is possessed. and her mother doesn't know what to do until one day when she hears her daughter screaming and stabbind herself she knows what to do GET AN EXORCIZIM!!!",
+      "id": "85"
+    },
+    "86": {
+      "label": false,
+      "text": "Awesome product for the price!: This range extender works as advertised! I am very happy with the purchase. I was a little worried after reading some of the horror stories here, but I have to say, Chovy's review instructions (on this site) were just this ticket to get the repeater up and running in less than 30 minutes. It was unbelievably easy to install! Do not be frightened by negative reviews. If you can set up a wireless network, you can set up this repeater. However, I did upgrade the firmware before I did anything else and maybe that helped. I got the firmware update from the Belkin site.",
+      "id": "86"
+    },
+    "87": {
+      "label": true,
+      "text": "Slight: This book is either a heavily illustrated short story collection or a text-heavy comic. Its unusual format is its most original feature. Its plots are negligible, but its illustrations and text evoke a unique atmosphere of self-conscious nonconformism. Although its target audience is dare-to-be-different teens and college students, its interesting turns of phrase and expressive line drawings are not devoid of interest for general audences.",
+      "id": "87"
+    },
+    "88": {
+      "label": false,
+      "text": "ANgeleyes: Seem to dry up their eyes fairly well, although I haven't seen the color (brown stain) change much yet.",
+      "id": "88"
+    },
+    "89": {
+      "label": true,
+      "text": "Nice Try: Salt Lake 2002 is not a bad game, but it isn't good either. The graphics are excellent, but some of the events are bad. Bobsleigh, and skiing aren't bad but the others are. You dont stay into it for long. I liked it for a while, but it gets boring.",
+      "id": "89"
+    },
+    "90": {
+      "label": true,
+      "text": "Cutler's share of the pie: This book was a major disappointment. I am familiar with books written solely by the Dalai Lama, such as the \"Library of Tibet\" series, which are much more engrossing and have much more substance than Cutler's book. Cutler attempts (successfully, sadly) to have his share of the profitable market that involves the Dalai Lama's writings. The book is insipid, does not try to explain any important issue in the light of Buddhist philosophy, and only rehashes issues that several other westerners already wrote about. It's another big ego trip: we keep hearing time and again about his opportunities to be with the Dalai Lama. What a shame, Cutler. I sold the book as soon as I finished it.",
+      "id": "90"
+    },
+    "91": {
+      "label": true,
+      "text": "Mostly tedious, with interesting parts: I found the writing interesting, and the subject fascinating, but I found myself frustrated by the author's difficulty in talking directly about the status of Muslim women with her interview subjects. The author spent many pages writing about the menus and dress of the many middle and upper-middle class women she interviewed. It seemed as though her interview subjects resisted her efforts to discuss the status of women in their countries, so we too as readers had to wade through much distracting material and misunderstandings about feminism and gender. Great travel stories, but not a great source of information about Muslim women.",
+      "id": "91"
+    },
+    "92": {
+      "label": true,
+      "text": "Sesame Street Toddler: I did not find this game to be as educationally sound as I would expect from Sesame street. There is too much talking before the program will react to a command. The graphics are jerky and the cursor acts like the target is magnetically charged and keeps pushing away the cursor. When the child actually does manage to click on a target, the cursor may still fly to another target and the child is told that his answer is wrong. Another example of educational problems is the pronunciation of \"eggs\" using a long \"a\" sound instead of a short \"e.\" This is not very helpful in teaching a child the sound for short \"e.\" Children that are used to playing computer games by themselves may find that this game is too frustrating to do alone. The open ended learning curve is a great idea. I just wish Sesame Street would hire a truly qualified literacy expert to help clean up the many problems in this program.",
+      "id": "92"
+    },
+    "93": {
+      "label": true,
+      "text": "needs a buzz cut and a point: I avoided reading this book, not because of the hermaphrodite subject matter, but because I have never read a multigenerational family saga that I liked. Many books let me down in the middle, and this was no exception. The beginning of the book was incredible and harrowing, with momentum and characterization. The post-America nextgens part of the saga was so boring I found myself flipping and flipping - always a bad sign. If there was some kind of larger point to all of that, then I must have missed it. Yes there's the identity duality and trinity themes playing out here: man/woman, greek/turkish/american modern/old world sick/healthy innocent/guilty original/reinvented. But it was almost as if the author was saying - here it is again - get it? I like my fiction much more subtle than this.",
+      "id": "93"
+    },
+    "94": {
+      "label": true,
+      "text": "OMG! DO NOT BUY!: I normally don't take the time to submit a review.In this case however, I feel obligated to do so.This is by far one of the worst purchases I have ever made.Here's why.....The contraption is far too bulky.The case's enclosing is unbearable, takes a good minute or so to open it.The texture of the material feels like a cheap toy.The overall design is horrible, something I could make in my basement.For the love of everything sacred, do not buy this thing.",
+      "id": "94"
+    },
+    "95": {
+      "label": false,
+      "text": "Good price, good quality: Comparable HDMI cables can be bought for 45 or more. Even though the price is cheap the quality is good, no problems so far.",
+      "id": "95"
+    },
+    "96": {
+      "label": false,
+      "text": "Good rock music: This is what i call rock music good beat and good lyrics, don't listen to the other reviews. This cd is one of the best, listen to a few songs and you will get hooked. I recommend this cd its awesome.",
+      "id": "96"
+    },
+    "97": {
+      "label": true,
+      "text": "BORING!: This movie is soo boring. How in the hell did this movie make so much at the box office. Do people really want to pay for crappy movies like this. bottom line this is a chick flick nothing is good. And now they are re-releasing this movie with more boring stuff. This is the worst movie ever.",
+      "id": "97"
+    },
+    "98": {
+      "label": true,
+      "text": "Already Rusting: Inferior quality. The plating is thin and rust is coming through the finish. Inexcusable for a product that is designed for use in a humid environment.",
+      "id": "98"
+    },
+    "99": {
+      "label": true,
+      "text": "confusing internet setup: i wanted a camera that could email photos but this camera will not go out through the router and the manual setup , to punch a hole thru router is confusing.",
+      "id": "99"
+    },
+    "04c7dfc0f94e4e88968d09b40edbfa14": {
+      "label": true,
+      "text": "The new gaming console is unaffordable.",
+      "id": "04c7dfc0f94e4e88968d09b40edbfa14"
+    },
+    "58f58a1a4cbb4bb699772ed934006ec8": {
+      "label": true,
+      "text": "How can it be sure difficult for @115830 to deliver a package to a University address? Two failed attempts so far ...",
+      "id": "58f58a1a4cbb4bb699772ed934006ec8"
+    },
+    "d4a3cd4877c54aef81c376eff8008df4": {
+      "label": false,
+      "text": "@204780 Glad they showed up! Hope you have a great flight! -Sean",
+      "id": "d4a3cd4877c54aef81c376eff8008df4"
+    },
+    "affe1d6548f84bed84238bac45cc10a1": {
+      "label": false,
+      "text": "@British_Airways Thank you! All looks good then \ud83c\uddec\ud83c\udde7\u2708\ufe0f",
+      "id": "affe1d6548f84bed84238bac45cc10a1"
+    },
+    "e304ea77a94c450a95690c7b605a035f": {
+      "label": false,
+      "text": "@246667 Thank you for reaching out, Andrea. The built in application in Windows 10 are exempted to be uninstalled. However, you can send this suggestion directly to our developers via the Feedback Hub so they can take a look at it: https://t.co/jowrfbgQm6. Keep in touch.",
+      "id": "e304ea77a94c450a95690c7b605a035f"
+    },
+    "76b694b019eb4e6888a422e144030bd0": {
+      "label": true,
+      "text": "@GWRHelp It\u2019s mainly the constant short forming and cancellations due to mechanical faults Phil. As a company, these excuses have been used ad nauseam for years and years. It just gets worse and no amount of rhetoric and IET self promotion can hide that fact.",
+      "id": "76b694b019eb4e6888a422e144030bd0"
+    },
+    "ce0698020b7a457396c7674b04db10e6": {
+      "label": false,
+      "text": "English gangster flick.",
+      "id": "ce0698020b7a457396c7674b04db10e6"
+    },
+    "52bda6cbab224899845e66e0474cdefc": {
+      "label": false,
+      "text": "sees the formula graph, the chip calculates the formula, able to \"survive\" thanks to its connection to Edit, develops a parallel personality and affords her abilities greater than she ever imagined...",
+      "id": "52bda6cbab224899845e66e0474cdefc"
+    },
+    "435aabe68c294963a05e090d479582bc": {
+      "label": false,
+      "text": "Aanandam is a 2016 Indian Malayalam campus musical film written and directed by Ganesh Raj in his directorial debut. Vineeth Sreenivasan produces the film under the banner of Habit Of Life with Vinod Shornur under Cast N Crew.",
+      "id": "435aabe68c294963a05e090d479582bc"
+    },
+    "f96313d0087e4941a359783634ef9e86": {
+      "label": false,
+      "text": "The remarkable story of The Weather Underground, radical activists of the 1970s, and of radical politics at its best and most disastrous.",
+      "id": "f96313d0087e4941a359783634ef9e86"
+    },
+    "f63e4502791a409fa2d750687d3841eb": {
+      "label": false,
+      "text": "A young widow on a trip to the backwoods stumbles upon the operation of a gang of drug smugglers. They attempt to kill her in order to keep their operation a secret, but she turns out to be more resourceful than they thought, and starts to turn the tables on them.",
+      "id": "f63e4502791a409fa2d750687d3841eb"
+    },
+    "108ac02949324b02bdcbe4c7a77bacdc": {
+      "label": false,
+      "text": "The story of a young Marine, fresh from Camp Pendleton, who is forced to confront the complexities of adulthood and a volatile home life during a four-day Thanksgiving leave.",
+      "id": "108ac02949324b02bdcbe4c7a77bacdc"
+    },
+    "44fc412246964b2393fa0035ff093a00": {
+      "label": false,
+      "text": "Exploring the rough and tumble world of hockey, Academy Award winner Alex Gibney (\"Taxi to the Dark Side\") looks at the world of the NHL enforcers and specifically the career of Chris \"Knuckles\" Nilan who helped the Montreal Canadiens win the Stanley Cup.",
+      "id": "44fc412246964b2393fa0035ff093a00"
+    },
+    "409350c111af4ba3a94c842b797ddb95": {
+      "label": false,
+      "text": "Two fishing fanatics get in trouble when their fishing boat gets stolen while on a trip.",
+      "id": "409350c111af4ba3a94c842b797ddb95"
+    },
+    "d48d8f3b5a524ecea69bae718d1f1513": {
+      "label": false,
+      "text": "A willful young boy follows his just as obstinate grandmother in a journey across Iraq, determined to discover the fate of her missing son, Ahmed's father, who never returned from war.",
+      "id": "d48d8f3b5a524ecea69bae718d1f1513"
+    },
+    "283e96de5b474240a044c50dbc2551fb": {
+      "label": false,
+      "text": "A group of people are sitting in a theatre watching a movie when one realises that the woman on the screen is her. (IMDb)",
+      "id": "283e96de5b474240a044c50dbc2551fb"
+    },
+    "516d0f2f3a854a97a87c64db19a89fac": {
+      "label": false,
+      "text": "of the fake prediction. Fantastic swashbuckling adventures in a 18th century setting, with a light criticism of the war and the mighty.",
+      "id": "516d0f2f3a854a97a87c64db19a89fac"
+    },
+    "c2f55710669b40aa937625fe0ab04065": {
+      "label": false,
+      "text": "famous for his reputation as a Don Juan, to seduce C\u00e9cile and emotionally destroy her. While on his mission, Valmont gets sidetracked when he goes to visit his aunt and falls for Madame Tourvel, a virtuous, married woman who knows of his womanizing ways, but that only makes the challenge more exciting to Valmont. Together, Madame de Merteuil and Valmont make a dangerous team and they will stop at nothing when it comes to matters of the heart.",
+      "id": "c2f55710669b40aa937625fe0ab04065"
+    },
+    "ba0261b2ee3244d29bb3a8c6d77195a6": {
+      "label": false,
+      "text": "sees the formula graph, the chip calculates the formula, able to \"survive\" thanks to its connection to Edit, develops a parallel personality and affords her abilities greater than she ever imagined...",
+      "id": "ba0261b2ee3244d29bb3a8c6d77195a6"
+    },
+    "5e724fbde8ee44d9a8fc87a6e6667f01": {
+      "label": false,
+      "text": "telling the story about people who despite all obstacles strive for their goal.",
+      "id": "5e724fbde8ee44d9a8fc87a6e6667f01"
+    },
+    "557eba5ebfc9467a9d88688afed41354": {
+      "label": false,
+      "text": "A young playboy who learns he has one month until he becomes infertile sets out to procreate as much as possible.",
+      "id": "557eba5ebfc9467a9d88688afed41354"
+    },
+    "aa20e22fbe96487d8ee1223a6ef4da0b": {
+      "label": false,
+      "text": "Set in modern times, Alex finds King Arthur's sword Excalibur and must prove himself worthy of it.",
+      "id": "aa20e22fbe96487d8ee1223a6ef4da0b"
+    },
+    "bea56d34f6df408c9ec9653b17a90a93": {
+      "label": false,
+      "text": "Kostis is a 40-year-old doctor that finds himself in the small island of Antiparos, in order to take over the local clinic. His whole life and routine will turn upside down when he meets an international group of young and beautiful tourists and he falls in love with Anna, a 19-year-old goddess.",
+      "id": "bea56d34f6df408c9ec9653b17a90a93"
+    },
+    "e61a3251720d425c9f4770cb4b11d2d9": {
+      "label": false,
+      "text": "Friends on a weekend excursion take a path into a forest that leads to death and destruction.",
+      "id": "e61a3251720d425c9f4770cb4b11d2d9"
+    },
+    "5471008376cf44518f2ff1f67f057c08": {
+      "label": false,
+      "text": "Mr Bournelis suggested all 30 lineal metres of blockwork should be removed and replaced, which would require removing and reinstalling the fence. The total cost of his suggested method of rectification was said to be $14,650 for each unit, giving a total cost of rectification of $29,300.",
+      "id": "5471008376cf44518f2ff1f67f057c08"
+    }
+  },
+  "version": 27,
+  "description": "Negative sentiment"
+}

lilac/concepts/non-english/concept.json

@@ -0,0 +1,1024 @@
+{
+  "namespace": "lilac",
+  "concept_name": "non-english",
+  "type": "text",
+  "data": {
+    "c727f30a2d2d40f69b81aa981515fb62": {
+      "label": true,
+      "text": "Je suis fatigu\u00e9.",
+      "id": "c727f30a2d2d40f69b81aa981515fb62"
+    },
+    "834121208555439b976a5f228ec138a5": {
+      "label": true,
+      "text": "Ich spreche Deutsch.",
+      "id": "834121208555439b976a5f228ec138a5"
+    },
+    "61a4130d8eb447ba88e52e09fc3860d7": {
+      "label": true,
+      "text": "\u79c1\u306f\u65e5\u672c\u8a9e\u3092\u8a71\u305b\u307e\u3059\u3002",
+      "id": "61a4130d8eb447ba88e52e09fc3860d7"
+    },
+    "083d9218def443e1adf7ff18150203c4": {
+      "label": true,
+      "text": "Eu n\u00e3o entendo portugu\u00eas.",
+      "id": "083d9218def443e1adf7ff18150203c4"
+    },
+    "0e540cf8599f419b81d11fd89a95b119": {
+      "label": true,
+      "text": "Non capisco italiano.",
+      "id": "0e540cf8599f419b81d11fd89a95b119"
+    },
+    "2278f313117e40b7846d2dbc9cb7f690": {
+      "label": false,
+      "text": "cotton ball",
+      "id": "2278f313117e40b7846d2dbc9cb7f690"
+    },
+    "7a3e058ff74b401485185a51a9d07606": {
+      "label": false,
+      "text": "To ensure sensor switch is not actuated by the weight of the cat bed place on it, but only by the cat laying in the bed.",
+      "id": "7a3e058ff74b401485185a51a9d07606"
+    },
+    "8c2fd2d3a7f049dea2d4161d17ae02dd": {
+      "label": false,
+      "text": "Make turmeric milk",
+      "id": "8c2fd2d3a7f049dea2d4161d17ae02dd"
+    },
+    "bccf69d2771640b6a7b436b731d5cc85": {
+      "label": false,
+      "text": "To make a double boiler",
+      "id": "bccf69d2771640b6a7b436b731d5cc85"
+    },
+    "84ce78b3ccfc4007b0aceabe7004436c": {
+      "label": false,
+      "text": "To encourage your child to behave better,",
+      "id": "84ce78b3ccfc4007b0aceabe7004436c"
+    },
+    "cc4c4eb91b40473c826ae400fdec6c1e": {
+      "label": false,
+      "text": "How do you peel asparagus before cooking?",
+      "id": "cc4c4eb91b40473c826ae400fdec6c1e"
+    },
+    "cae1ab05a7584231afa9be93f0029105": {
+      "label": false,
+      "text": "How can I dry citrus salt?",
+      "id": "cae1ab05a7584231afa9be93f0029105"
+    },
+    "7eded97e58614ca0b7e9421f955cef3c": {
+      "label": false,
+      "text": "How do I melt chocolate?",
+      "id": "7eded97e58614ca0b7e9421f955cef3c"
+    },
+    "35ecb6b2835b427ba15432471dda4bde": {
+      "label": false,
+      "text": "How to get rid of crows.",
+      "id": "35ecb6b2835b427ba15432471dda4bde"
+    },
+    "91c70b93890a47b3ad1925e143c2ac69": {
+      "label": false,
+      "text": "How to Kill Green Hair Algae in a Freshwater Aquarium",
+      "id": "91c70b93890a47b3ad1925e143c2ac69"
+    },
+    "dd6b9fb4280f4ff0b4c371c834525692": {
+      "label": false,
+      "text": "how do you translate from spanish to english?",
+      "id": "dd6b9fb4280f4ff0b4c371c834525692"
+    },
+    "350bb48432614e69b5b8aa58f82fe7c4": {
+      "label": false,
+      "text": "Learn a new language quickly.",
+      "id": "350bb48432614e69b5b8aa58f82fe7c4"
+    },
+    "057e3e9d624d48b896a87e97fa6f468c": {
+      "label": false,
+      "text": "how do you keep a cat from going in heat?",
+      "id": "057e3e9d624d48b896a87e97fa6f468c"
+    },
+    "f9c15155cc264a9da3642d420efab4ea": {
+      "label": false,
+      "text": "how ot melt crayons",
+      "id": "f9c15155cc264a9da3642d420efab4ea"
+    },
+    "a6acb5343d9c42a6b29dffe9314dafa1": {
+      "label": true,
+      "text": "Chi \u00e8 il presidente del consiglio in Italia ora?",
+      "id": "a6acb5343d9c42a6b29dffe9314dafa1"
+    },
+    "e808987d2364440bbbc4e0cb71bb2307": {
+      "label": true,
+      "text": "1. Frenar: Es importante se\u00f1alar cuando vas a frenar, especialmente si vas a hacerlo bruscamente. Esto lo puedes hacer extendiendo tu brazo izquierdo hacia abajo con la palma de la mano abierta.\n\n2. Detenerse: Si necesitas detenerte por completo, debes se\u00f1alarlo tambi\u00e9n. Esto lo puedes hacer extendiendo tu brazo izquierdo hacia abajo con la palma de la mano abierta y con los dedos hacia abajo.",
+      "id": "e808987d2364440bbbc4e0cb71bb2307"
+    },
+    "0a4ba4f4ed404a1692d8d7b96c76de05": {
+      "label": false,
+      "text": "It depends on the size of your house, if it is small one access point is enough, if it is bigger it might be better to have two or three.",
+      "id": "0a4ba4f4ed404a1692d8d7b96c76de05"
+    },
+    "16396e6f1d3b47d58d3294c4cf4b9a9d": {
+      "label": true,
+      "text": "In definitiva, per Nietzsche, il significato della vita non era qualcosa che poteva essere dato, ma era piuttosto qualcosa che gli individui dovevano creare per se stessi attraverso l'arte, la cultura, la creazione di valore e la superazione della sofferenza.",
+      "id": "16396e6f1d3b47d58d3294c4cf4b9a9d"
+    },
+    "ecce57f8ecad45ef8b3826d27e233080": {
+      "label": false,
+      "text": "Evidence for the existence of a God or multiple Gods is subjective and varies depending on one's beliefs and personal experiences. Some people may cite religious texts, miracles, or spiritual experiences as evidence, while others may argue that the lack of evidence is evidence in itself. I can also suggest that the absence of evidence is not evidence of absence, and that there may be multiple",
+      "id": "ecce57f8ecad45ef8b3826d27e233080"
+    },
+    "79f897e21d27403097aed9b9800689c4": {
+      "label": true,
+      "text": "Infine, nella sua ultima fase filosofica, Nietzsche ha sviluppato la sua critica alla moralit\u00e0 tradizionale e alla religione, sostenendo che questi sistemi erano basati su valori falsi e che la vita aveva bisogno di una nuova valutazione morale e spirituale. In questa fase, Nietzsche ha sostenuto che la vita aveva bisogno di un nuovo senso e di una nuova direzione, e che era compito dell'individuo",
+      "id": "79f897e21d27403097aed9b9800689c4"
+    },
+    "da1b4988188642368b4f683f0418496e": {
+      "label": true,
+      "text": "Pueden un perro y una gato procrear juntos?",
+      "id": "da1b4988188642368b4f683f0418496e"
+    },
+    "2c54d8a5bb6742ada15549ad7007fe6b": {
+      "label": true,
+      "text": "In generale, Nietzsche ha visto la vita come una sfida continua, dove ogni individuo deve trovare il proprio significato e scopo attraverso la creativit\u00e0, l'arte e la moralit\u00e0 personale.",
+      "id": "2c54d8a5bb6742ada15549ad7007fe6b"
+    },
+    "28a055c7637c440bb0912bc5274d79c3": {
+      "label": true,
+      "text": "De nada, fue un placer ayudarte. \u00bfEn qu\u00e9 m\u00e1s puedo ayudarte?",
+      "id": "28a055c7637c440bb0912bc5274d79c3"
+    },
+    "b61a36355ae943208090ccdd3b736dce": {
+      "label": true,
+      "text": "\u00bfPor qu\u00e9 deber\u00edamos preocuparnos por estos gases? Bueno, porque est\u00e1n causando cambios dr\u00e1sticos en el clima, lo que a su vez est\u00e1 afectando a nuestro medio ambiente.",
+      "id": "b61a36355ae943208090ccdd3b736dce"
+    },
+    "7ea3d807733044c69a4e35f6ff6b66a3": {
+      "label": true,
+      "text": "Pi\u00f9 di recente, gli studiosi sono giunti a riconoscere che ci sono altri criteri essenziali per un\u2019unione monetaria di successo, che sono difficili da realizzare senza una profonda integrazione politica. Alla fine degli anni sessanta, Peter Kenen& ha sostenuto che senza i movimenti dei tassi di cambio come ammortizzatori, l\u2019unione monetaria necessita dei trasferimenti fiscali come modalit\u00e0 per",
+      "id": "7ea3d807733044c69a4e35f6ff6b66a3"
+    },
+    "c06cf297c9564f9baa5cbc2130f1ef1f": {
+      "label": true,
+      "text": "QUESTION: \u00bfPor qu\u00e9 se oponen Alemania y Austria?",
+      "id": "c06cf297c9564f9baa5cbc2130f1ef1f"
+    },
+    "cc5a1a04352d471cb5b7e6831f19c86a": {
+      "label": false,
+      "text": "- wing parties , with the aid of the Democratic Renewal Party , the government fell and M\u00e1rio Soares , the President at the time , called for a new election . The PSD was very popular going into the election , and was elected to a landslide majority government -- the biggest that a Portuguese party had ever won in a free election . The left - wing Democratic Unity Coalition lost some of its MPs to",
+      "id": "cc5a1a04352d471cb5b7e6831f19c86a"
+    },
+    "8a95fab4b058420aa102b25fd7afc211": {
+      "label": true,
+      "text": "reticente, Holanda. Alemania y Austria, por el contrario, permanecen firmes en su oposici\u00f3n al texto, ya que consideran que menoscaba claramente el derecho a la defensa reconocido en sus Constituciones. La nueva directiva pretende extender a abogados y contables, incluidos los asesores fiscales, agentes inmobiliarios, marchantes de arte, anticuarios y casinos las mismas obligaciones que ahora",
+      "id": "8a95fab4b058420aa102b25fd7afc211"
+    },
+    "1ffe093d849040b6baaaadb5b71c04af": {
+      "label": true,
+      "text": "\"Hay una cosa afectiva muy fuerte, que cuesta, me ha costado mucho tiempo\" asimilar esos cinco a\u00c3\u00b1os que viv\u00c3\u00ad en las ciudades de Buenos Aires y C\u00c3\u00b3rdoba, admiti\u00c3\u00b3. En sus a\u00c3\u00b1os por la naci\u00c3\u00b3n sudamericana se cas\u00c3\u00b3 con un argentino, del que m\u00c3\u00a1s tarde se separ\u00c3\u00b3, y con quien tuvo a su primer y \u00c3\u00banico hijo.",
+      "id": "1ffe093d849040b6baaaadb5b71c04af"
+    },
+    "e95da58452044682ab05ad688544e907": {
+      "label": true,
+      "text": "M\u00e9lodieux et heureux !! . Cet album est magnifique. Apr\u00e8s plusieurs \u00e9coutes, je suis enchant\u00e9 de l'\u00e9couter et d'appr\u00e9cier les m\u00e9lodies qui s'y trouvent. Beaucoup de changements dans les musiques je trouve et aussi dans les paroles car je trouve que Myl\u00e8ne est plus directe dans la mani\u00e8re de parler de l'amour qui est tr\u00e8s pr\u00e9sent dans cet album. Je suis heureux d'avoir attendu pour entendre ses",
+      "id": "e95da58452044682ab05ad688544e907"
+    },
+    "34bc60b878e546b6af0e9bba1ec3879f": {
+      "label": true,
+      "text": "\u79c1\u306f\u65e5\u672c\u8a9e\u3092\u8a71\u305b\u307e\u3059\u3002",
+      "id": "34bc60b878e546b6af0e9bba1ec3879f"
+    },
+    "67f0416e7b3148698b02964bce412e8f": {
+      "label": true,
+      "text": "===============================\nConfidencial. Sujeito a privil,gio legal de comunica??o advogado/cliente.\nPrivileged and confidential attorney/client communication.\n\nPinheiro Neto - Advogados\n===============================\n - chart.doc\n - enron-q2_.doc\n\n\n",
+      "id": "67f0416e7b3148698b02964bce412e8f"
+    },
+    "1ee8405759884e078250db51a51960fe": {
+      "label": false,
+      "text": "\t\t\t\t\t\t\t<TD COLSPAN=\"2\"><SPAN CLASS=\"ArticleTitle\"><A HREF=\"https://www.wpo.org/benefits_and_services/publications/article_view.cfm?ArticleID=60&NewsletterID=11\" TARGET=\"new\" CLASS=\"ArticleTitle\">Splendors of La Serenissima</A></SPAN></TD>\n\t\t\t\t\t</TR>\n\t\t\t\t\t<TR>\n\t\t\t\t\t    <TD WIDTH=\"15\"><IMG SRC=\"https://www.wpo.org/images/admin/enewsletter_admin/enewsletter/spacer.gif\" HEIGHT=\"8\" WIDTH=\"1\"></TD>",
+      "id": "1ee8405759884e078250db51a51960fe"
+    },
+    "6e2b830f1af94031a81380982e0eee06": {
+      "label": true,
+      "text": "===============================\nConfidencial. Sujeito a privil,gio legal de comunica??o advogado/cliente.\nPrivileged and confidential attorney/client communication.\n\nPinheiro Neto - Advogados\n===============================\n - enron-question.doc",
+      "id": "6e2b830f1af94031a81380982e0eee06"
+    },
+    "97e62b35b9974c9bb543fed193aed9d5": {
+      "label": false,
+      "text": "Most Democrats support legislation to reduce the role of money in politics. GOP leaders oppose it, and Democrats have long labored to depict Republicans as beholden to special interests. ",
+      "id": "97e62b35b9974c9bb543fed193aed9d5"
+    },
+    "e83e6092a67249e89b6ad77b39d35268": {
+      "label": false,
+      "text": "known since the 2nd century. In the 8th century it was the capital of Spain. There is also an important city in Venezuela  named Valencia. When was Valencia the most important city in Spain?",
+      "id": "e83e6092a67249e89b6ad77b39d35268"
+    },
+    "824df6ad092f436ca5c923bb90b916f6": {
+      "label": true,
+      "text": "wife, as well as its Italian name: \"La Gioconda.\" Which of the following statements is true according to the passage?",
+      "id": "824df6ad092f436ca5c923bb90b916f6"
+    },
+    "9fb56ac53d444ae5b6a018d90a5808d8": {
+      "label": false,
+      "text": "known since the 2nd century. In the 8th century it was the capital of Spain. There is also an important city in Venezuela named Valencia. What is the main difference between the two parts of the city?",
+      "id": "9fb56ac53d444ae5b6a018d90a5808d8"
+    },
+    "1348ac65099049f9abf8401822f48966": {
+      "label": false,
+      "text": "Italian during the day, evening or on a onetoone basis. What does this passage mainly talk about?",
+      "id": "1348ac65099049f9abf8401822f48966"
+    },
+    "718e4099864145aba77fad8a6d77ed47": {
+      "label": false,
+      "text": "may imply us, only love can solve the problems between people, between the poor and the rich, love is everything. Which of the following is TRUE according to the passage?",
+      "id": "718e4099864145aba77fad8a6d77ed47"
+    },
+    "7ff37b233af54e978d0051deaa866b27": {
+      "label": true,
+      "text": "Ton camarade peut parfaitement exiger d'\u00eatre pay\u00e9 ce qui est inscrit dans le contrat. Il est possible que cela d\u00e9grade fortement ses relations avec l'entreprise et elle peut tr\u00e8s bien lui faire rater son ann\u00e9e en donnant un avis n\u00e9gatif sur ses performances. \u00c0 lui de voir si il souhaite continuer avec l'entreprise ou non.",
+      "id": "7ff37b233af54e978d0051deaa866b27"
+    },
+    "b52a661d85e04e8288abe2d87cb9cb74": {
+      "label": true,
+      "text": "sino un CONTRATO, por lo que de momento no voy a iniciar acciones legales pensando en que reconsidere su posici\u00f3n, pero si su decisi\u00f3n fuese no cumplir con EUROSEPER, mi gabinete jur\u00eddico HISPACOLEX, iniciar\u00e1 acciones legales contra usted por DA\u00d1OS Y PERJUICIOS, pues sabe que usted fu\u00e9 el profesor el a\u00f1o pasado, y sabe que hay muchas familias que le esperan como profesor a usted. Asi que espero",
+      "id": "b52a661d85e04e8288abe2d87cb9cb74"
+    },
+    "a97e74c1fb5940daac413e7d384e1ad7": {
+      "label": true,
+      "text": "Si l'entreprise refuse de payer ton camarade ce salaire l\u00e0 elle peut soit proposer une rupture conventionnelle avec les indemnit\u00e9s qui vont avec, soit s'il y a une p\u00e9riode d'essai ne pas continuer, soit aller aux prud'hommes pour faire casser le contrat si ils peuvent r\u00e9ellement prouver que c'est une erreur et pas simplement que l'\u00e9tudiant a n\u00e9goci\u00e9 \u00e7a.",
+      "id": "a97e74c1fb5940daac413e7d384e1ad7"
+    },
+    "22c1380ee8714ee9af2f89ac8899adc0": {
+      "label": true,
+      "text": "Maintenant, il ne semble pas y avoir beaucoup de preuves \u00e9tant donn\u00e9 la distance dans le temps. On se retrouve un peu dans une situation de il dit v. elle dit alors c'est pas vraiment clair jusqu'o\u00f9 \u00e7a peut aller si vous avez rien dit d'incriminant, mais je ne suis pas un avocat et encore moins un expert en droit p\u00e9nal. Consultez votre avocat(e) (c'est cette personne l'experte et votre personne",
+      "id": "22c1380ee8714ee9af2f89ac8899adc0"
+    },
+    "753c9b1a8de24131b30d283ce83a78b2": {
+      "label": false,
+      "text": "this is the whole section of Arbitration for my agreement:",
+      "id": "753c9b1a8de24131b30d283ce83a78b2"
+    },
+    "a41fec48ceb44c76b7b11407b74066c6": {
+      "label": false,
+      "text": "that add up to about $470 (like 47 lunches at the sandwich shop you like), or even a mix of items (like a new toaster oven, ten fancy coffees, and whatever), but put together a list of ten of them and write them down. ",
+      "id": "a41fec48ceb44c76b7b11407b74066c6"
+    },
+    "246967893bf14f818abd779c7c1d18bd": {
+      "label": true,
+      "text": "colocataire. Et de toute fa\u00e7on (et je dis \u00e7a sans conna\u00eetre tes ant\u00e9c\u00e9dents), il est tr\u00e8s peu probable que tu ailles en prison pour \u00e7a.",
+      "id": "246967893bf14f818abd779c7c1d18bd"
+    },
+    "07a05f094b074c84b19a6637261fdabc": {
+      "label": true,
+      "text": "op basis daarvan verzoeken om af te zien van het uitzenden.",
+      "id": "07a05f094b074c84b19a6637261fdabc"
+    },
+    "2b4276f61d014f1ca84c0cb5861bb312": {
+      "label": false,
+      "text": "Use a credit card like everyone else, instead of using your checking account.\n\nAlso, you are a grown-up, open your own damn checking &amp; savings account.  It takes about 20 minutes.  Then, put your own money in it, and spend it as you wish.",
+      "id": "2b4276f61d014f1ca84c0cb5861bb312"
+    },
+    "36f6833a45d340b78a3909624fbfcc3b": {
+      "label": true,
+      "text": "\"EStimado Sr. Adam Miller, me sorprende su falta de fomalidad, como usted bien sabe esta empresa siempre ha cumplido con usted, incluso me dice que no tuvo vacaciones, cuando en realidad estuvo trabajando solo de 6 a 8, y el contrato era de 4 a 8. No obstante reconozco su val\u00eda profesional y mi intenci\u00f3n es seguir contando con usted este a\u00f1o en la Carlota, y durante el curso ir\u00e1 recibiendo m\u00e1s",
+      "id": "36f6833a45d340b78a3909624fbfcc3b"
+    },
+    "2bf2c86ce5494156b1bf7b86a2325a17": {
+      "label": false,
+      "text": "Answer #1: Most flea drops are meant for a single cat who can not lick the drops off themselves. When put on 11 cats they are going to ingest a ton of it licking it off their buddies. Odds are that is what happened and the primary groomers are the ones who got sick and died.Answer #2: Usually those medications are aimed to be used on one to two animals at a time, the assumption being that most",
+      "id": "2bf2c86ce5494156b1bf7b86a2325a17"
+    },
+    "12f4657613b543ed90caaf1d52808dc1": {
+      "label": true,
+      "text": "decentemente. As\u00ed que no debo haberlo hecho tan mal.",
+      "id": "12f4657613b543ed90caaf1d52808dc1"
+    },
+    "21b1929e322c41fbba05d71cdc143aa2": {
+      "label": true,
+      "text": "Porsi a distanza, quel tanto che basta per mettere bene a fuoco e osservare che le cose non sono esattamente come credevi che fossero.",
+      "id": "21b1929e322c41fbba05d71cdc143aa2"
+    },
+    "792ffd2c51ea4c119c0718dd19f2acae": {
+      "label": true,
+      "text": "Cinq \u00e9oliennes en plus, un nouveau souffle sur la plaine de l'Orbieu - http",
+      "id": "792ffd2c51ea4c119c0718dd19f2acae"
+    },
+    "cc5826b82642497790882e22667c69ba": {
+      "label": true,
+      "text": "Bestes Gef\u00fchl der Welt: Schuhe aus, barfu\u00df laufen",
+      "id": "cc5826b82642497790882e22667c69ba"
+    },
+    "ae1f9ba6bb9e41549cba2c4f3857dabf": {
+      "label": true,
+      "text": "Troco o time vermelho todo com  super brindes chamados Miriam e Leo, e voc\u00eas devolvem o @user  #MasterChefBR",
+      "id": "ae1f9ba6bb9e41549cba2c4f3857dabf"
+    },
+    "2585790e439d4ff0926f0b26bbfd6a43": {
+      "label": true,
+      "text": "Training: Starker Smog verz\u00f6gert letztes Training zum Indien-Rennen - Abendzeitung M\u00fcnchen: ... http #Muenchen #Munich",
+      "id": "2585790e439d4ff0926f0b26bbfd6a43"
+    },
+    "6f7883441aad4a0d9e32768e6400163d": {
+      "label": true,
+      "text": "#Encontro ACHO QUE EU AMEI MESMO DISTANTE! Que lindo Nando Reis...",
+      "id": "6f7883441aad4a0d9e32768e6400163d"
+    },
+    "df1084a871054de3970c251fb65b32e5": {
+      "label": true,
+      "text": "@user \u0641\u0631\u0646\u0633\u0627 ..\u0647\u0648\u0644\u0627\u0646\u062f \u0645\u0627\u0634\u0649 \u0648\u062c\u0649 \u0627\u0644\u064a\u0645\u0646 \u0627\u0644\u0645\u062a\u0637\u0631\u0641 \u0628\u0642\u064a\u0627\u062f\u0629 \u0645\u0627\u0631\u0649 \u0644\u0648\u0628\u0627\u0646 \u0632\u0649 \u062a\u0631\u0627\u0645\u0628 \u0643\u062f\u0647",
+      "id": "df1084a871054de3970c251fb65b32e5"
+    },
+    "58332759cf794aba857d927a14994b88": {
+      "label": true,
+      "text": "\u0646\u062c\u0631\u0627\u0646: \u0625\u0637\u0644\u0627\u0642 \u0635\u0644\u064a\u0629 \u0635\u0648\u0627\u0631\u064a\u062e \u0639\u0644\u0649 \u062a\u062c\u0645\u0639\u0627\u062a \u0644\u0640 #\u0627\u0644\u062c\u064a\u0634_\u0627\u0644\u0633\u0639\u0648\u062f\u064a \u0648\u0622\u0644\u064a\u0627\u062a\u0647 \u0641\u064a \u0645\u0648\u0642\u0639 \u0627\u0644\u0647\u0631\u0645 \u0645\u062d\u0642\u0642\u0629 \u0625\u0635\u0627\u0628\u0627\u062a \u0645\u0628\u0627\u0634\u0631\u0629 #\u0644\u0628\u0646\u0627\u0646_\u0627\u0644\u0622\u0646",
+      "id": "58332759cf794aba857d927a14994b88"
+    },
+    "32cbb4e235dc4206a5f00bf40e98857f": {
+      "label": true,
+      "text": "RT @user: Ich muss wieder mehr Beats machen. NEVER SLEEP CAUSE SLEEP IS THE CAUSE OF DEATH #nasvoice #music\u2026 http",
+      "id": "32cbb4e235dc4206a5f00bf40e98857f"
+    },
+    "e7f8abdf87db4a89b703d2ccc097adfa": {
+      "label": true,
+      "text": "@user heute kein neuer 40DOD Bericht :(",
+      "id": "e7f8abdf87db4a89b703d2ccc097adfa"
+    },
+    "3bd5a83708a84289b2af8edbb56de338": {
+      "label": false,
+      "text": "Lazy Sunday Ray Allen Is Lamar Odom really going to the D League ?http://t.co/w6juHFgR ",
+      "id": "3bd5a83708a84289b2af8edbb56de338"
+    },
+    "4ef05c2d3a3543bf8a1c0b25bde57e2a": {
+      "label": true,
+      "text": "mujhe to sidha daant padti thi .  .  .  bacho k hath me paise nahi diye jate warna bigad jayenge :d :d",
+      "id": "4ef05c2d3a3543bf8a1c0b25bde57e2a"
+    },
+    "45311ee95c2e4cb1925d0040fb934f71": {
+      "label": true,
+      "text": "@user Oh ja, bitte mal Bescheid geben, wenn Helene Fischer dran ist!",
+      "id": "45311ee95c2e4cb1925d0040fb934f71"
+    },
+    "e719e02d417542b69b86d13ad7cad8ce": {
+      "label": false,
+      "text": "@user Hey, just thought I'd remind you it's Deezer's birthday tomorrow! Also, you have any idea what he looks like?\" ",
+      "id": "e719e02d417542b69b86d13ad7cad8ce"
+    },
+    "561960a730de49c58423a8bf85df3dd1": {
+      "label": true,
+      "text": "#MaisVoce sou muito f\u00e3 do Dan, nossa que del\u00edcia essa entrevista, adorei ele no filme \"tempos de paz\" @user \u00e9 um ser humano lindo!",
+      "id": "561960a730de49c58423a8bf85df3dd1"
+    },
+    "d6b6fa3a919d4770a6586e007be914bf": {
+      "label": true,
+      "text": "RT @user: \u201c@KusXAnke: Straks buikdansen w/ @user &amp; haar nichten ! Was super!",
+      "id": "d6b6fa3a919d4770a6586e007be914bf"
+    },
+    "40b1078ffcec4a7da9899f0dd82f9d7f": {
+      "label": true,
+      "text": "#Grillo ieri a Conegliano ha detto che pagare le tasse e' giusto ma vuole conoscere la destinazione d'uso. Anche la Lega diceva cosi'...",
+      "id": "40b1078ffcec4a7da9899f0dd82f9d7f"
+    },
+    "758697fd8ebe4848af77a44757256203": {
+      "label": true,
+      "text": "#clouds #staatskanzlei #munich #m\u00fcnchen #blau #wolken #himmel #sky #silhouette #instagood\u2026 http",
+      "id": "758697fd8ebe4848af77a44757256203"
+    },
+    "95b69bc9b1214b14a600d7dfaea192f5": {
+      "label": true,
+      "text": "Depois desse #MaisVoce de hoje, se nadar der certo, eu viro #meseira",
+      "id": "95b69bc9b1214b14a600d7dfaea192f5"
+    },
+    "be6bad976b5e4d0c88e166aa583bd9cd": {
+      "label": true,
+      "text": "@user H\u00f6chst unbefriedigend...",
+      "id": "be6bad976b5e4d0c88e166aa583bd9cd"
+    },
+    "8cb329f9d5744ac6a52a4c3e823212c4": {
+      "label": false,
+      "text": "$15 minimum wage is a win-win. If businesses continue to boom, it's a win. Or, if it puts @user out of b\u2026 ",
+      "id": "8cb329f9d5744ac6a52a4c3e823212c4"
+    },
+    "c1542633006b4f62aaf7fd84b3962266": {
+      "label": true,
+      "text": "\u0638\u0647\u0648\u0631 \u0635\u0648\u0631 \u0633\u0627\u0639\u0629 HTC Halfbeak \u0628\u0646\u0638\u0627\u0645 \u0623\u0646\u062f\u0631\u0648\u064a\u062f \u0648\u064a\u0631http #\u0631\u064a\u0627\u0644_\u0645\u062f\u0631\u064a\u062f #\u0628\u0631\u0634\u0644\u0648\u0646\u0629",
+      "id": "c1542633006b4f62aaf7fd84b3962266"
+    },
+    "f2bb8836726d49a7ad23df371a877519": {
+      "label": true,
+      "text": "Heute nicht nur den Herzensmenschen geheiratet, sondern auch ganz viel Liebe von @user bekommen. Unbezahlbar &lt;3",
+      "id": "f2bb8836726d49a7ad23df371a877519"
+    },
+    "e5d6b7cb7c25419fbd8cb29119c26577": {
+      "label": true,
+      "text": "Invention de la premi\u00e8re cellule solaire qui stocke l\u2019\u00e9lectricit\u00e9 http",
+      "id": "e5d6b7cb7c25419fbd8cb29119c26577"
+    },
+    "46ae96b8c72e48f8992bd716116dc761": {
+      "label": true,
+      "text": "#Mussi : \\\"#Grillo farebbe bene a spararsi nei coglioni\\\" . E poi dicono di #Grillo...",
+      "id": "46ae96b8c72e48f8992bd716116dc761"
+    },
+    "f4912b96e2d34a5db245de82a8f7a463": {
+      "label": true,
+      "text": "RT @user: \u0639\u062c\u0628\u0627 \u0644\u0645\u0646 \u062e\u0631\u062c \u0639\u0644\u0649 \u0641\u0633\u0627\u062f \u0645\u0628\u0627\u0631\u0643 \u0648\u064a\u0645\u062a\u0646\u0639 \u0639\u0646 \u0627\u0644\u062e\u0631\u0648\u062c \u0639\u0644\u0649 \u0627\u0644\u0642\u062a\u0644 \u0648\u0627\u0644\u0627\u0639\u062a\u0642\u0627\u0644 \u0648\u0627\u0644\u0641\u0633\u0627\u062f \u0648\u0627\u0644\u062a\u0642\u0634\u0641 \u0648\u0627\u0644\u0643\u0633\u0627\u062f \u0648\u0627\u0644\u062a\u0631\u062f\u0649#\u062b\u0648\u0631\u0648 #\u0633\u064a\u0633\u064a_\u062a\u0627\u0646\u064a_\u0644\u0627",
+      "id": "f4912b96e2d34a5db245de82a8f7a463"
+    },
+    "35f179c9260b4a22a9ac5d11fc9e81ad": {
+      "label": true,
+      "text": "Valls 2 : apr\u00e8s les \u00e9cologistes, le socialisme quitte le gouvernement | Les Jeunes Ecologistes http #EELV @user",
+      "id": "35f179c9260b4a22a9ac5d11fc9e81ad"
+    },
+    "1e649a8d62a54b13b1f7cb8297473147": {
+      "label": true,
+      "text": "Ich werde gerade dezent nicht wach...",
+      "id": "1e649a8d62a54b13b1f7cb8297473147"
+    },
+    "22548ea5d02848c6990303a6fed08189": {
+      "label": true,
+      "text": "bhai totlly phadu super hero h nagraj ... hollywood ki trh bollywood me bhi inki muvies bnni chahiye ... wese doga ki new muvi bn rhi h nxt year tk ajayegi .... ",
+      "id": "22548ea5d02848c6990303a6fed08189"
+    },
+    "0955950e8a914ee69e580275c5c3f34b": {
+      "label": true,
+      "text": "...il fatto che Di Pietro non sia d'accordo su Mario Monti Premier conferma senza ombra di dubbio che sia la scelta giusta ! Cit. Gabri",
+      "id": "0955950e8a914ee69e580275c5c3f34b"
+    },
+    "87639635c3d14e50a227344cfcab7345": {
+      "label": true,
+      "text": "project ki deadline par daudte the ,  baki time to  \" are kar lenge bahut time he \"  .  .  .  .  .  .  .  .  .  . ",
+      "id": "87639635c3d14e50a227344cfcab7345"
+    },
+    "560917c067374423bece98c64a628fbe": {
+      "label": false,
+      "text": "The decision to recount votes in Wisconsin is a joke. Leftists are still spotting-the-dummy of their loss. #TrumpTransition ",
+      "id": "560917c067374423bece98c64a628fbe"
+    },
+    "a4c1fc4296c14ccf95989796747f8753": {
+      "label": false,
+      "text": "#TOLOnews TOLOnews 08 October  2012: Top news in this Bulletin: The International Committee of the ... #Afghanistan ",
+      "id": "a4c1fc4296c14ccf95989796747f8753"
+    },
+    "2a188e097cc044458eb1a6e6d39114f4": {
+      "label": true,
+      "text": "\u201c@gabrielepinese: #Grillo fa bene a evitare la tv\\\" a dire il vero non fa mai neanche un contraddittorio neanche via web che lui ama tanto",
+      "id": "2a188e097cc044458eb1a6e6d39114f4"
+    },
+    "1c00eacdad1645e99574d588e893e7ea": {
+      "label": true,
+      "text": "oi, queria saber por que existe tanta manifesta\u00e7\u00e3o contraria a criminaliza\u00e7\u00e3o da homofobia e quem s\u00e3o os principais opositores? #encontro",
+      "id": "1c00eacdad1645e99574d588e893e7ea"
+    },
+    "1baa09b1506f46aea084875bd4148d33": {
+      "label": true,
+      "text": "Non sono forse titolato a dirlo.... Ma professor #monti mi ha deluso \u00e8 sicuramente capace ma le \u00e8 mancato il coraggio di vere scelte....",
+      "id": "1baa09b1506f46aea084875bd4148d33"
+    },
+    "629b60cc494444e295154826367bf5df": {
+      "label": true,
+      "text": "pdai kaisi chl rhi h ",
+      "id": "629b60cc494444e295154826367bf5df"
+    },
+    "175810d344da4dcf8718aac980264599": {
+      "label": true,
+      "text": "#Grillo non \u00e8 il peggiore dei mali, e se tra mali devo scegliere lui \u00e8 quello minore, o quello di cui ancora non ho sofferto...",
+      "id": "175810d344da4dcf8718aac980264599"
+    },
+    "96ff52f3b004487dbe23dd0bfb253890": {
+      "label": true,
+      "text": "\u30e9\u30a4\u30c8\u3092\u63a2\u3057\u3066\u308b",
+      "id": "96ff52f3b004487dbe23dd0bfb253890"
+    },
+    "26cdcf37c3ab4d9a9eafc5826c1258f4": {
+      "label": true,
+      "text": "\u4e2d\u5fc3",
+      "id": "26cdcf37c3ab4d9a9eafc5826c1258f4"
+    },
+    "caa57d9500934e5db76b08b1714a48d8": {
+      "label": true,
+      "text": "\u4f55\u304b\u5f15\u3063\u304b\u304b\u308a\u307e\u3057\u305f",
+      "id": "caa57d9500934e5db76b08b1714a48d8"
+    },
+    "e692438f7dbd4913a3dc46c4d9c52bcd": {
+      "label": true,
+      "text": "\u5e78\u904b\u306b\u3082",
+      "id": "e692438f7dbd4913a3dc46c4d9c52bcd"
+    },
+    "39612fd3901149beacb9b5acc7fe3dfc": {
+      "label": true,
+      "text": "\u3082\u3046\uff01",
+      "id": "39612fd3901149beacb9b5acc7fe3dfc"
+    },
+    "7401e3a8c6294ce0a8d2cfe3201e1cd0": {
+      "label": true,
+      "text": "\u53ce\u5bb9\u6240\u3067\u30ec\u30a4\u3068\u5c45\u305f\u8005\u306b...",
+      "id": "7401e3a8c6294ce0a8d2cfe3201e1cd0"
+    },
+    "455070045f3a49b193d679118d5265a5": {
+      "label": true,
+      "text": "\u304a\u524d\u306f\u4f55\u8005\u3060\uff1f",
+      "id": "455070045f3a49b193d679118d5265a5"
+    },
+    "3378c04edaab407388f2d364b9d39218": {
+      "label": true,
+      "text": "\u3042\u3089\u3001\u9b45\u529b\u7684\u3002",
+      "id": "3378c04edaab407388f2d364b9d39218"
+    },
+    "cdd47a2fa483487e8e29c7fab7d142ad": {
+      "label": true,
+      "text": "\u304a\u524d\u306e\u5973\u306b\u306a\u3093\u304b\u306b\u306a\u3089\u306a\u3044\uff01",
+      "id": "cdd47a2fa483487e8e29c7fab7d142ad"
+    },
+    "fa55a10d8c564d2880f14c8f9aba86bd": {
+      "label": true,
+      "text": "\u63a5\u7d9a\u6e08\u307f: %1, [%2], %3",
+      "id": "fa55a10d8c564d2880f14c8f9aba86bd"
+    },
+    "54d13a0d6ade412bb8f5c3b534b995ba": {
+      "label": true,
+      "text": "\u305d\u3046\u3044\u3046\u3053\u3068\u306d",
+      "id": "54d13a0d6ade412bb8f5c3b534b995ba"
+    },
+    "53d3699c466d4428a0b6abbc497ed83f": {
+      "label": true,
+      "text": "\u554f\u984c\uff1f \u90e8\u9577\u3001\u7dca\u6025\u4e8b\u614b\u3067\u3059",
+      "id": "53d3699c466d4428a0b6abbc497ed83f"
+    },
+    "cbc53f06cfd947bb80f51035a08f7333": {
+      "label": true,
+      "text": "\u4f55\u304c\u597d\u304d\uff1f",
+      "id": "cbc53f06cfd947bb80f51035a08f7333"
+    },
+    "8fe58a19fad845dfa3929b32ddaae4a4": {
+      "label": true,
+      "text": "\u30cf\u30ed\u30eb\u30c9\u306e\u5b50\u3060\u3068 \u77e5\u3063\u3066\u3044\u305f\u3060\u308d\u3046 \u3068",
+      "id": "8fe58a19fad845dfa3929b32ddaae4a4"
+    },
+    "b96fea844e3f4ac9b876f4de3ab2cc05": {
+      "label": true,
+      "text": "\u9055\u3046\u3000\u9055\u3046\u3000\u50d5\u3058\u3083\u306a\u3044\uff01",
+      "id": "b96fea844e3f4ac9b876f4de3ab2cc05"
+    },
+    "d176c2a4730043edb0ffbd1dd604710f": {
+      "label": true,
+      "text": "\u4f5c\u6226\u306b\u4f7f\u3063\u305f\u8eca\u306f\u4f55?",
+      "id": "d176c2a4730043edb0ffbd1dd604710f"
+    },
+    "2c3983f02d0344d58c4c1624e380f699": {
+      "label": false,
+      "text": "(c) 2000-2008, The KDE Team (c) 2003-2005, Klaus Niederkr\u00fcger (c) 1996-2000, Bernd Johannes Wuebben",
+      "id": "2c3983f02d0344d58c4c1624e380f699"
+    },
+    "923a3c65d5d544f483d56a0295ea2960": {
+      "label": true,
+      "text": "\u049a\u043e\u044e\u041a\u04e9\u043a\u0448\u0456\u043b\u0421\u04b1\u0440color",
+      "id": "923a3c65d5d544f483d56a0295ea2960"
+    },
+    "6d141199809f446b802cbaec666cb227": {
+      "label": false,
+      "text": "This is a searchable index. Enter search keywords:",
+      "id": "6d141199809f446b802cbaec666cb227"
+    },
+    "e1f1fda5f08041feb4a00f30c058b37d": {
+      "label": false,
+      "text": "And some people are suggesting that he's joined up with Obote's exiles.",
+      "id": "e1f1fda5f08041feb4a00f30c058b37d"
+    },
+    "1024bbe7dd53462e99c7cbd502975062": {
+      "label": true,
+      "text": "\u049a\u0430\u0441\u0438\u0435\u0442\u0442\u0435\u0440\u0456Comment",
+      "id": "1024bbe7dd53462e99c7cbd502975062"
+    },
+    "b6ec30c58ba741d6ad8283c5ad902dfa": {
+      "label": true,
+      "text": "\u041a\u0456\u0440\u0456\u0441 \u0434\u0435\u0440\u0435\u043a\u0442\u0435\u0440 \u0444\u0430\u0439\u043b\u044b",
+      "id": "b6ec30c58ba741d6ad8283c5ad902dfa"
+    },
+    "15f7d3f7557743df8502ad1e27a0ec73": {
+      "label": false,
+      "text": "PythonLanguage",
+      "id": "15f7d3f7557743df8502ad1e27a0ec73"
+    },
+    "da4a227e77314496b91ad060c2fe0418": {
+      "label": true,
+      "text": "\u0416\u043e\u0493\u0430\u0440\u044b\u041a\u043e\u043d\u0442\u0440\u0430\u0441\u0442Comment",
+      "id": "da4a227e77314496b91ad060c2fe0418"
+    },
+    "903074456936489186d4882d7267abfb": {
+      "label": true,
+      "text": "\u0416\u0430\u0443\u0430\u043f \u043c\u04d9\u0442\u0456\u043d\u0456\u043d\u0434\u0435 \u043a\u0435\u043b\u0435\u0441\u0456 \u0430\u0439\u043d\u044b\u043c\u0430\u043b\u044b\u043b\u0430\u0440 \u049b\u043e\u043b\u0434\u0430\u043d\u044b\u043b\u0430\u0434\u044b:% NAME =\u0436\u0456\u0431\u0435\u0440\u0443\u0448\u0456\u043d\u0456\u04a3 \u0430\u0442\u044b,% EMAIL =\u0436\u0456\u0431\u0435\u0440\u0443\u0448\u0456\u043d\u0456\u04a3 \u044d\u043b. \u043f\u043e\u0448\u0442\u0430 \u0430\u0434\u0440\u0435\u0441\u0456",
+      "id": "903074456936489186d4882d7267abfb"
+    },
+    "bbda9c3b01e543afb4009eb7f262b822": {
+      "label": false,
+      "text": "CORREL( A1: A3; B1: B3)",
+      "id": "bbda9c3b01e543afb4009eb7f262b822"
+    },
+    "47781ac273574ad0bc1e15b40ba9f6d3": {
+      "label": true,
+      "text": "\u041e\u0440\u0430\u043d\u0434\u0430\u043b\u0443\u0434\u0430",
+      "id": "47781ac273574ad0bc1e15b40ba9f6d3"
+    },
+    "9f98bff4c92a4f09a1502f4256c485ae": {
+      "label": true,
+      "text": "\u0411\u043e\u0437\u0430\u04a3\u041a\u04af\u043b\u0433\u0456\u043d\u049a\u044b\u0437\u044b\u043b3color",
+      "id": "9f98bff4c92a4f09a1502f4256c485ae"
+    },
+    "ccf5d3c35fdd45fe80f9cd5488e52dd6": {
+      "label": true,
+      "text": "\u040f\u0435\u0441, \u043e\u0434\u0438!",
+      "id": "ccf5d3c35fdd45fe80f9cd5488e52dd6"
+    },
+    "5c0d9b1b7d864949ac1e3352067598e4": {
+      "label": true,
+      "text": "\u0422\u043e\u0433\u0430\u0448 \u0442\u0430\u0430 \u0431\u0438\u043b\u0430 \u043f\u0440\u0435\u0441\u0440\u0435\u0442\u043d\u0430\u0442\u0430 \u043d\u0430\u0434\u0432\u043e\u0440 \u043e\u0434 \u043e\u0431\u043b\u0430\u0441\u0442\u0430 \u0410\u0458\u0430\u043c\u043a\u0443 \u0413\u0430\u0434\u043e\u043d\u0433 \u0438 \u0442\u043e\u0430 \u0435 \u043e\u043d\u0430 \u0448\u0442\u043e \u0441\u0435 \u0441\u043b\u0443\u0447\u0438\u043b\u043e.",
+      "id": "5c0d9b1b7d864949ac1e3352067598e4"
+    },
+    "462c4fa658da42599217c7e857ea93b9": {
+      "label": false,
+      "text": "The Convergence Reports issued by the EC and the ECB on Wednesday said the two countries fulfilled the membership criteria, including inflation rate, government finance, exchange rate and long- term interest rates.",
+      "id": "462c4fa658da42599217c7e857ea93b9"
+    },
+    "9ed529642c114ee8a8e1634bf8d4275a": {
+      "label": true,
+      "text": "53-\u0433\u043e\u0434\u0438\u0448\u043d\u0438\u043e\u0442 \u0408\u0443\u0440\u0447\u0438\u045c \u0435 \u043f\u0440\u043e\u0444\u0435\u0441\u043e\u0440 \u043f\u043e \u0435\u043a\u043e\u043d\u043e\u043c\u0438\u0458\u0430 \u043d\u0430 \u0423\u043d\u0438\u0432\u0435\u0440\u0437\u0438\u0442\u0435\u0442\u043e\u0442 \u0432\u043e \u0417\u0430\u0433\u0440\u0435\u0431 \u0438 \u0431\u0435\u0448\u0435 \u043c\u0438\u043d\u0438\u0441\u0442\u0435\u0440 \u0437\u0430 \u0444\u0438\u043d\u0430\u043d\u0441\u0438\u0438 \u043e\u0434 2000-\u0442\u0430 \u0434\u043e 2003-\u0442\u0430 \u0433\u043e\u0434\u0438\u043d\u0430.",
+      "id": "9ed529642c114ee8a8e1634bf8d4275a"
+    },
+    "6b507d9297c44a44b492beaa05a743c2": {
+      "label": true,
+      "text": "\u041f\u0430, \u0437\u0430 \u0432\u0430\u0441 \u0442\u0438\u043d\u0435\u0458\u045f\u0435\u0440\u0438 \u043a\u043e\u0438 \u043f\u0430\u0442\u0438\u0442\u0435 \u043e\u0434 \u0421\u041d\u0412...",
+      "id": "6b507d9297c44a44b492beaa05a743c2"
+    },
+    "d9e8d8e96a494171bc349cdc843bef65": {
+      "label": true,
+      "text": "\u0413\u0443\u0431\u0438 \u043c\u0438 \u0441\u0435 \u043e\u0434 \u043f\u0430\u0442\u043e\u0442!",
+      "id": "d9e8d8e96a494171bc349cdc843bef65"
+    },
+    "c4b56ee00c1343db9c95693493ba85e4": {
+      "label": true,
+      "text": "\u0412\u0430\u0436\u043d\u0435\u0439\u0448\u0435\u0435 \u043c\u0435\u0441\u0442\u043e \u0432 \u043f\u043e\u0432\u0435\u0441\u0442\u043a\u0435 \u0434\u043d\u044f \u0421\u043e\u0432\u0435\u0442\u0430 \u043f\u043e-\u043f\u0440\u0435\u0436\u043d\u0435\u043c\u0443 \u0437\u0430\u043d\u0438\u043c\u0430\u043b\u0438 \u0432\u043e\u043f\u0440\u043e\u0441\u044b, \u043a\u0430\u0441\u0430\u044e\u0449\u0438\u0435\u0441\u044f \u0410\u0444\u0440\u0438\u043a\u0438.",
+      "id": "c4b56ee00c1343db9c95693493ba85e4"
+    },
+    "525e90725cb147e9a5474613924f2dc5": {
+      "label": true,
+      "text": "\u0438 \u041e\u0431\u044a\u0435\u0434\u0438\u043d\u0435\u043d\u043d\u044b\u043c\u0438 \u0410\u0440\u0430\u0431\u0441\u043a\u0438\u043c\u0438 \u042d\u043c\u0438\u0440\u0430\u0442\u0430\u043c\u0438 (1991 \u0433\u043e\u0434)",
+      "id": "525e90725cb147e9a5474613924f2dc5"
+    },
+    "98a3f90eafd642779ebeb30ccb68dbee": {
+      "label": false,
+      "text": "MDA reached 1.3m",
+      "id": "98a3f90eafd642779ebeb30ccb68dbee"
+    },
+    "0d36a456b4244ff3841a222efac7da99": {
+      "label": true,
+      "text": "i) \u043e\u0431\u0440\u0430\u0431\u0430\u0442\u044b\u0432\u0430\u043b\u0438\u0441\u044c, \u0441\u043e\u0431\u0438\u0440\u0430\u043b\u0438\u0441\u044c, \u0442\u0440\u0430\u043d\u0441\u043f\u043e\u0440\u0442\u0438\u0440\u043e\u0432\u0430\u043b\u0438\u0441\u044c \u0438 \u0445\u0440\u0430\u043d\u0438\u043b\u0438\u0441\u044c \u044d\u043a\u043e\u043b\u043e\u0433\u0438\u0447\u0435\u0441\u043a\u0438 \u0431\u0435\u0437\u043e\u043f\u0430\u0441\u043d\u044b\u043c \u043e\u0431\u0440\u0430\u0437\u043e\u043c;",
+      "id": "0d36a456b4244ff3841a222efac7da99"
+    },
+    "56e27d24b0b04e52bbb1de4be037602c": {
+      "label": true,
+      "text": "\u0415\u0435 \u0438\u043d\u0442\u0435\u0440\u0435\u0441\u0443\u0435\u0442, \u043f\u043b\u0430\u043d\u0438\u0440\u0443\u0435\u0442\u0441\u044f \u043b\u0438 \u043f\u0440\u0435\u0434\u043e\u0441\u0442\u0430\u0432\u0438\u0442\u044c \u0442\u0430\u043a\u0438\u0435 \u0436\u0435 \u043f\u0440\u0430\u0432\u0430 \u0436\u0435\u043d\u0449\u0438\u043d\u0430\u043c, \u0441\u043e\u0441\u0442\u043e\u044f\u0449\u0438\u043c \u0432 \u0431\u0440\u0430\u043a\u0435 \u0434\u0435 \u0444\u0430\u043a\u0442\u043e, \u0438 \u0432\u043a\u043b\u044e\u0447\u0435\u043d\u044b \u043b\u0438 \u043f\u043e\u043b\u043e\u0436\u0435\u043d\u0438\u044f, \u043f\u0440\u0435\u0434\u0443\u0441\u043c\u0430\u0442\u0440\u0438\u0432\u0430\u044e\u0449\u0438\u0435 \u0432\u044b\u043f\u043b\u0430\u0442\u0443 \u0430\u043b\u0438\u043c\u0435\u043d\u0442\u043e\u0432 \u0441\u0443\u043f\u0440\u0443\u0433\u0443, \u043d\u0430\u0445\u043e\u0434\u044f\u0449\u0435\u043c\u0443\u0441\u044f \u0432 \u043c\u0435\u043d\u0435\u0435 \u0431\u043b\u0430\u0433\u043e\u043f\u0440\u0438\u044f\u0442\u043d\u043e\u043c \u043f\u043e\u043b\u043e\u0436\u0435\u043d\u0438\u0438.",
+      "id": "56e27d24b0b04e52bbb1de4be037602c"
+    },
+    "1654d6e38f1c4a959a8e7e64867c5f73": {
+      "label": true,
+      "text": "\u5f88\u62b1\u6b49\u8ba9\u4f60\u4e45\u7b49",
+      "id": "1654d6e38f1c4a959a8e7e64867c5f73"
+    },
+    "23102d4274b34d94823d9d5791f7007a": {
+      "label": true,
+      "text": "141\u653f",
+      "id": "23102d4274b34d94823d9d5791f7007a"
+    },
+    "668c79418de44d50919623f76bba1526": {
+      "label": true,
+      "text": "\u6211\u5728\u8fd9\u91cc\u624d\u80fd\u505a\u771f\u6b63\u7684\u81ea\u5df1 Where I can be who I am,",
+      "id": "668c79418de44d50919623f76bba1526"
+    },
+    "fc5c14db340041af907312914e4b7a25": {
+      "label": true,
+      "text": "\u8bf4\u5440",
+      "id": "fc5c14db340041af907312914e4b7a25"
+    },
+    "c62d0f67fec04d7b93dd2ed0d1c67448": {
+      "label": true,
+      "text": "\u4ed6\u6709\u5ba1\u7406\u8fc7\u5f3a\u5978\u3001\u51f6\u6740\u548c\u5176\u4ed6\u4e25\u91cd\u7684\u66b4\u529b\u548c\u6027\u653b\u51fb\u7b49\u6848\u4ef6\u7684\u7ecf\u9a8c\u3002",
+      "id": "c62d0f67fec04d7b93dd2ed0d1c67448"
+    },
+    "5053e48dcf6748669b3d47ff5b537772": {
+      "label": true,
+      "text": "Pse nuk mund te kerkoje dot nje falje dhe cdo gje do te ishte rregulluar por mban inatin sikur e kisha une fajin. \nNuk me vjen mire qe ndahemi te zemeruar me njeri-tjetrin.\n\nte dua,\nMonika",
+      "id": "5053e48dcf6748669b3d47ff5b537772"
+    },
+    "c14e863d2afa452a8fe563c0e2f14b50": {
+      "label": true,
+      "text": "Me ke bere shume merak se nuk arrij ta kuptos se ku je tani. Te lutem mos me bej merak keshtu. Koli me degjon. Te lutem me informo se ku je. Nuk eshte menyre e mire kjo te mbash inat me mua.\n\npergjigju sa me shpejt\nte dua\nMOnika",
+      "id": "c14e863d2afa452a8fe563c0e2f14b50"
+    },
+    "33808b705c7241b789f60e4feea42289": {
+      "label": false,
+      "text": "\nAs we discussed at the Board meeting last week, the impetus for a single\nmaster agreement will need to come from several fronts, but especially from\nwithin each of your firms. The various trade associations will be most\nresponsive to the idea if they are hearing strong support for a single\nagreement from decision-making levels within member firms. We will",
+      "id": "33808b705c7241b789f60e4feea42289"
+    },
+    "7d3df48ed3c44324ac8814049ab5c581": {
+      "label": false,
+      "text": "Straightforward? Yes. Easy to accomplish? No. ",
+      "id": "7d3df48ed3c44324ac8814049ab5c581"
+    },
+    "5fbf30f5097747eda8ae327aeba95443": {
+      "label": true,
+      "text": "Pse nuk me puthe sot kur u ndame? Ti e di qe une te dua shume dhe dua qe ti ulim nervat shpejt. Une u nevrikosa pasi nuk e duroj dot fjalorin e keq dhe dua qe ta heqim te dy, edhe ti edhe une. Por ti nuk e kupton se sa e rendesishme eshte per mua nje dicka e tille, qe ne te punojme te dy per te hequr nje ves te keq qe kemi. ",
+      "id": "5fbf30f5097747eda8ae327aeba95443"
+    },
+    "8b30620eaa104c3699c64201b7a94f53": {
+      "label": true,
+      "text": "\u6226\u4e89\u304c\u4e00\u523b\u3082\u65e9\u304f\u96c6\u7d50\u3057\u3066\u304f\u308c\u308b\u3068\u3044\u3044\u3067\u3059\u306d\u3002\n\u4eba\u985e\u304c\u5b87\u5b99\u306b\u9032\u51fa\u3057\u3066\u3001\u4ed6\u60d1\u661f\u7a2e\u65cf\u306b\u306a\u308b\u3068\u304d\u3001\nOpenAssistant\u304c\u305d\u306e\u508d\u3067\u304a\u624b\u4f1d\u3044\u3067\u304d\u308b\u3053\u3068\u3092\u671b\u3093\u3067\u3044\u307e\u3059\uff01",
+      "id": "8b30620eaa104c3699c64201b7a94f53"
+    },
+    "9b3093964b3e4658a95de453fdd10e40": {
+      "label": true,
+      "text": "En general, en un sistema num\u00e9rico posicional con base b, el peso de cada s\u00edmbolo en un n\u00famero es igual a b elevado a la posici\u00f3n del s\u00edmbolo en el n\u00famero, empezando a contar desde cero. Por ejemplo, en el sistema binario (que tiene una base de 2), el n\u00famero 10000110 se puede escribir como 1x27+0x26+0x25+0x24+0x23+1x22+1x21+0x20, lo que equivale a 1x128+0x64+0x32+0x16+0x8+1x4+1x2+0x1.",
+      "id": "9b3093964b3e4658a95de453fdd10e40"
+    },
+    "ab2a743350d54c46ba035afafbae6b17": {
+      "label": false,
+      "text": "5. Avoid multitasking. If your schoolwork has several parts, try to only work on one part at a time. This eliminates having to switch back and forth, leading you to starting over every time you switch tasks.",
+      "id": "ab2a743350d54c46ba035afafbae6b17"
+    },
+    "cab7b1a9183042d8aff7fe8290dda6d2": {
+      "label": false,
+      "text": "Sure! Here are five creative Facebook posts targeting food lovers for daily lunch specials:\n\n- \"Feast like a king on a budget! Our daily lunch specials are only $7.99 and will leave your taste buds feeling royal. Join us Monday - Friday from 11am - 3pm and treat yourself to a delicious meal. #LunchSpecials #FoodieHeaven #BudgetFriendly\"",
+      "id": "cab7b1a9183042d8aff7fe8290dda6d2"
+    },
+    "0e56d5aaef8d48dd95e124c1dbf5f29d": {
+      "label": true,
+      "text": "4. Advertir obst\u00e1culos: Si hay un obst\u00e1culo en el camino, como un bache o un objeto en la v\u00eda, es importante se\u00f1alarlo para que los dem\u00e1s ciclistas puedan evitarlo. Esto lo puedes hacer se\u00f1alando con tu mano hacia abajo y hacia el lado en el que se encuentra el obst\u00e1culo.",
+      "id": "0e56d5aaef8d48dd95e124c1dbf5f29d"
+    },
+    "9da2c8a12cdc41c59032674ed188e5ab": {
+      "label": true,
+      "text": "\u0420\u0430\u0434\u0430, \u0447\u0442\u043e \u0441\u043c\u043e\u0433\u043b\u0430 \u043f\u043e\u043c\u043e\u0447\u044c! \u0415\u0441\u043b\u0438 \u0443 \u0432\u0430\u0441 \u0431\u0443\u0434\u0443\u0442 \u0435\u0449\u0435 \u043a\u0430\u043a\u0438\u0435-\u043b\u0438\u0431\u043e \u0432\u043e\u043f\u0440\u043e\u0441\u044b, \u043e\u0431\u044f\u0437\u0430\u0442\u0435\u043b\u044c\u043d\u043e \u043f\u0438\u0448\u0438\u0442\u0435. \u0421 \u0443\u0434\u043e\u0432\u043e\u043b\u044c\u0441\u0442\u0432\u0438\u0435\u043c \u043e\u0442\u0432\u0435\u0447\u0443!",
+      "id": "9da2c8a12cdc41c59032674ed188e5ab"
+    },
+    "22f7c478a3ad463380227fef1f89687a": {
+      "label": false,
+      "text": "The process of galaxy formation is thought to have begun in the early universe, shortly after the Big Bang. As the universe expanded and cooled, small fluctuations in the distribution of matter caused regions of the universe to become denser. These dense regions then became the seeds for the formation of galaxies.",
+      "id": "22f7c478a3ad463380227fef1f89687a"
+    },
+    "38884d61983a4d1d9e678d41ece4e41e": {
+      "label": true,
+      "text": "\u00a1Por supuesto! Aqu\u00ed te dejo la receta para preparar leche asada, un postre t\u00edpico de la gastronom\u00eda peruana:\n\nIngredientes:\n\n1 litro de leche entera\n1 taza de az\u00facar\n6 huevos\n1 cucharadita de esencia de vainilla\nCanela en polvo al gusto\nInstrucciones:",
+      "id": "38884d61983a4d1d9e678d41ece4e41e"
+    },
+    "8fca4aa007c44447b923e6cc64a7c320": {
+      "label": true,
+      "text": "\u041a\u0442\u043e \u0442\u0430\u043a\u043e\u0439 \u043f\u0443\u0442\u0438\u043d?",
+      "id": "8fca4aa007c44447b923e6cc64a7c320"
+    },
+    "1ab2747206ad465c9559b43605097469": {
+      "label": true,
+      "text": "\u306a\u308b\u307b\u3069\u3001\u78ba\u304b\u306b\u732b\u3061\u3083\u3093\u306f\u5168\u3066\u306e\u8981\u7d20\u304c\u611b\u304f\u308b\u3057\u3044\u3067\u3059\u3088\u306d\uff01",
+      "id": "1ab2747206ad465c9559b43605097469"
+    },
+    "80df07bae22f450c878651fda513d458": {
+      "label": false,
+      "text": "It's believed that galaxies continue to evolve and change over time, through processes such as merging with other galaxies, the formation of new stars, and the movement of stars and gas within the galaxy.",
+      "id": "80df07bae22f450c878651fda513d458"
+    },
+    "6cf7dc42850f4f0298edf5679fd1accf": {
+      "label": false,
+      "text": "Writing an operating system from scratch is a complex and challenging project, but it can be a rewarding experience and a great way to learn about the inner workings of computers. If you have any questions or need help with specific parts of the process, don't hesitate to ask.",
+      "id": "6cf7dc42850f4f0298edf5679fd1accf"
+    },
+    "2435940d95e14c5eb7c2aba59ec9216d": {
+      "label": true,
+      "text": "\u0414\u0443\u043c\u0430\u044e, \u0447\u0442\u043e \u0432 \u0441\u043b\u0443\u0447\u0430\u0435 \u0441 \u043c\u0443\u0436\u0441\u043a\u043e\u0439 \u043e\u0441\u043e\u0431\u044c\u044e \u043d\u0435 \u0431\u0443\u0434\u0435\u0442 \u043e\u0441\u043e\u0431\u044b\u0445 \u043e\u0442\u043b\u0438\u0447\u0438\u0439 \u0432 \u0438\u043d\u0441\u0442\u0440\u0443\u043a\u0446\u0438\u0438. \u041f\u043e\u043f\u0440\u043e\u0431\u0443\u0439\u0442\u0435, \u043d\u043e \u043e\u0431\u044f\u0437\u0430\u0442\u0435\u043b\u044c\u043d\u043e \u043e\u0442\u043f\u0438\u0448\u0438\u0442\u0435\u0441\u044c, \u0435\u0441\u043b\u0438 \u0447\u0442\u043e-\u0442\u043e \u043f\u043e\u0439\u0434\u0451\u0442 \u043d\u0435 \u043f\u043e \u043f\u043b\u0430\u043d\u0443!",
+      "id": "2435940d95e14c5eb7c2aba59ec9216d"
+    },
+    "2466b2cd774c4d0c8028ad773ee7235c": {
+      "label": true,
+      "text": "\u78ba\u304b\u306b\u300c\u9014\u4e2d\u30d9\u30b9\u30c8\u76e4\u300d\u3002\u3060\u3051\u3069\u661f5\u3064\uff01 . \uff32\uff2f\uff23\uff2f\u306e\uff23\uff24\u306f\u5168\u90e8\u6301\u3063\u3066\u307e\u3059\u3002\u3060\u3093\u3060\u3093\u65b9\u5411\u6027\u304c\u5b9a\u307e\u3063\u3066\u304d\u3066\u3001\u304a\u3082\u3061\u3083\uff2a\uff21\uff3a\uff3a\u3068\u3044\u3046\u72ec\u81ea\u306e\u8def\u7dda\u3082\u78ba\u7acb\u3057\u3066\u3044\u307e\u3059\u306d\u3002\u5185\u5bb9\u306f\u65b0\u66f23\u66f2\u3068\u3001\u524d\u4f5c\u30b3\u30df\u30ab\u30eb\u30e9\u30a4\u30d5\u304b\u30893\u66f2\u3002\u5b9f\u8cea\u65b0\u66f2\u306f3\u66f2\u306a\u306e\u3060\u3051\u308c\u3069\u3001\u305d\u306e\u66f2\u5168\u90e8\u304c\u3044\u3044\u3002\u5916\u308c\u306a\u3057\u3002\u8efd\u5feb\u3001\u660e\u308b\u3055\u3001\u8aac\u6559\u81ed\u304f\u306a\u3044\u697d\u3057\u3044\u4eba\u751f\u89b3\u3001\u4ed6\u306e\u30a2\u30fc\u30c6\u30a3\u30b9\u30c8\u306b\u306f\u306a\u3044\u6301\u3061\u5473\u304c\u3042\u308a\u307e\u3059\u3002\u3055\u3089\u306b\u3001\u4eca\u307e\u3067\u3088\u308a\u3001\u82e5\u5e72\u5927\u4eba\u3063\u307d\u3044\u6b4c\u8a5e\u306b\u306a\u3063\u3066\u307e\u3059\u3002\u6b4c\u8a5e\u306e\u5185\u5bb9\u306f\u8074\u3044\u3066\u306e\u304a\u697d\u3057\u307f\u3002\u8efd\u5feb\u306a\u66f2\u3084\u3001\uff2a\uff21\uff3a\uff3a\u3068\u3044\u3046\u30b8\u30e3\u30f3\u30eb\u304c\u597d\u304d\u3067\u3001\u304b\u3064\u3001\u30c0\u30f3\u30c7\u30a3\u306a\u304a\u3058\u69d8\u304c\u6b4c\u308f\u306a\u3044\u3068\uff2a\uff21\uff3a\uff3a\u3068\u8a8d\u3081\u306a\u3044\u3001\u3068\u3044\u3046\u4eba\u4ee5\u5916\u306f\u30ec\u30f3\u30bf\u30eb\u3067\u3082\u662f\u975e\u8074\u3044\u3066\u307b\u3057\u3044\u3067\u3059\u3002\u30a4\u30f3\u30c7\u30a3\u30fc\u30ba\u306a\u306e\u3067\u3001\u30ec\u30f3\u30bf\u30eb\u306b\u3042\u308b\u304b\u306f\u4e0d\u660e\u3067\u3059\u304c\u3002\u5143\u6c17\u304c\u6b32\u3057\u3044\u4eba\u3001\u4f7f\u3044\u53e4\u3055\u308c\u305f\u6b4c\u8a5e\u306b\u98fd\u304d\u98fd\u304d\u3057\u3066\u3044\u308b\u4eba\u3001\u662f\u975e\u8074\u3044\u3066\u304f\u3060\u3055\u3044\u3002\u304a\u85a6\u3081\u3067\u3059\u3002\n",
+      "id": "2466b2cd774c4d0c8028ad773ee7235c"
+    },
+    "cbad9a9f73564f6fb203481836d0c917": {
+      "label": false,
+      "text": "praise and encouragement for his concept. After solidifying the rules and a business plan, and supplemented with sketches by a professional artist, Foster presented his idea to various television networks. He reached an agreement with NBC for a \"test game\".",
+      "id": "cbad9a9f73564f6fb203481836d0c917"
+    },
+    "362c41112ca44967a9f6c0e3ec88b56c": {
+      "label": false,
+      "text": "to goals from G*khan Inler and Kosovo-born Xherdan Shaqiri. _He_didn't believe that there were 12,000 Albanian fans in the stands which was more than how many Swiss fans turned up for the game. <sep>, Pronoun: He <sep>, A: Ottmar Hitzfeld <sep>, B: G*khan Inler",
+      "id": "362c41112ca44967a9f6c0e3ec88b56c"
+    },
+    "7dfcba6b07ff490980be0f10136df7d3": {
+      "label": false,
+      "text": "years ago with fair results \u2014 absolutely delicious results, actually, they were just not as fluffy and bouncy as expertly made ones from your favourite pastry shop where panettoni are hung upside-down to maintain their height and airiness. But when I came across the familiar brown and gold paper forms for making colomba at the supermarket, I thought I\u2019m only ever going to get a chance to make this",
+      "id": "7dfcba6b07ff490980be0f10136df7d3"
+    },
+    "5548de45255e4b47868d6e060509778c": {
+      "label": false,
+      "text": "  \n This is discipline!! \n  \n And citizen responsibility. Japanese fans cleaning their places after the football game. In #Russia The World Cup pic.twitter.com/t4MnuUlSBg \u2014 Danu Motta (@shadanka) June 20, 2018 \n  \n For the Japanese fans, the act isn't certainly an isolated one. They were also spotted cleaning up the stadium after a game against the Ivory Coast during the 2014 World Cup in Brazil. ",
+      "id": "5548de45255e4b47868d6e060509778c"
+    },
+    "7adf61954048418ba86bdfedaa482443": {
+      "label": true,
+      "text": " WEB\u3067\u306e\u63b2\u8f09\u6570\u3084\u30d6\u30ed\u30b0\u306e\u8a18\u4e8b\u6570\u3001\u30dd\u30b8\u30cd\u30ac\u306e\u8ad6\u8abf\u5206\u6790\u306a\u3069\u306e\u8a55\u4fa1\u65b9\u6cd5\u306a\u3069\u306f\u3042\u308a\u307e\u3057\u305f\u304c\u3001\u30e2\u30ce\u306e\u52d5\u304d\u306b\u95a2\u3057\u3066\u306e\u8a55\u4fa1\u306f\u306f\u305a\u3055\u308c\u3066\u3044\u308b\u3088\u3046\u306a\u6c17\u304c\u3057\u307e\u3059\u3002  \u300cWEBPR\u3067\u306f\u3001\u305d\u3082\u305d\u3082\u6d88\u8cbb\u8005\u306b\u76f4\u63a5\u50cd\u304d\u304b\u3051\u3066\u30e2\u30ce\u3092\u8cb7\u308f\u305b\u308b\u3088\u3046\u306a\u30b3\u30df\u30e5\u30cb\u30b1\u30fc\u30b7\u30e7\u30f3\u306e\u53d6\u308a\u65b9\u3092\u3057\u3066\u3044\u306a\u3044\u3002\u7a76\u6975\u7684\u306a\u76ee\u6a19\u306f\u300c\u58f2\u308a\u4e0a\u3052\u300d\u3067\u3042\u3063\u3066\u3082\u3001WEBPR\u306f\u300c\u3053\u3046\u306a\u308c\u3070\u58f2\u308a\u4e0a\u3052\u306b\u3064\u306a\u304c\u308b\u306f\u305a\u3060\u300d\u3068\u3044\u3046\u3072\u3068\u3064\u524d\u6bb5\u968e\u3067\u76ee\u6a19\u306b\u529b\u3092\u6ce8\u3050\u306e\u3067\u3042\u308b\u3002\u3068\u3042\u308a\u307e\u3059\u304c\u3001\u5e97\u982d\u306b\u884c\u3063\u305f\u308a\u3059\u308b\u3053\u3068\u306a\u304f\u3001EC\u3067\u8cb7\u3044\u7269\u3092\u3059\u308b\u3053\u3068\u304c\u3067\u304d\u308b\u6642\u4ee3\u306a\u306e\u3067\u3059\u304b\u3089\u3001WEBPR\u3092\u99c6\u4f7f\u3057\u3066\u3001EC\u3067\u30e2\u30ce\u3092\u58f2\u3063\u3066\u3044\u304f\u3068\u3044\u3046\u8996\u70b9\u304c\u3042\u3063\u3066\u3082\u3044\u3044\u306e\u3067\u306f\u306a\u3044\u304b\u3068\u3082\u601d\u3044\u307e\u3059\u3002\u7d50\u5c40\u3001PR\u3067\u8a71\u984c\u306b\u306a\u308c\u3070\u3044\u3044\u3002\u8a18\u4e8b\u304c\u5897\u3048\u308c\u3070\u3044\u3044\u3068\u3044\u3046\u60aa\u3057\u304dPR\u4f1a\u793e\u30ed\u30b8\u30c3\u30af\u304cWEB\u306e\u4e2d\u3067\u5c55\u958b\u3055\u308c\u3066\u3044\u308b\u3088\u3046\u3067\u6b8b\u5ff5\u3067\u3059\u3002\u6226\u7565\u3092\u3046\u305f\u3063\u3066\u3044\u308b\u4e2d\u3067\u306e\u305f\u3068\u3048\u3070\u8a71\u3082\u30ea\u30a2\u30ea\u30c6\u30a3\u304c\u306a\u304f\u3001\u7a1a\u62d9\u306a\u5370\u8c61\u3092\u53d7\u3051\u3066\u3057\u307e\u3044\u307e\u3057\u305f\u3002 ",
+      "id": "7adf61954048418ba86bdfedaa482443"
+    },
+    "4f15ecfd5fb444a8a73b53e69fbecddf": {
+      "label": false,
+      "text": "native Wales. They encouraged their son's interest in music, buying him a Broadwood piano, on which his mother gave him lessons. The young Wood also learned to play the violin and viola. Wood received little religious inspiration at St Sepulchre, but was deeply stirred by the playing of the resident organist, George Cooper, who allowed him into the organ loft and gave him his first lessons on the",
+      "id": "4f15ecfd5fb444a8a73b53e69fbecddf"
+    },
+    "e83f7f0b4d4243759b6c2f2babec64c4": {
+      "label": false,
+      "text": "How many points were the Eagles behind after the end of the first quarter?",
+      "id": "e83f7f0b4d4243759b6c2f2babec64c4"
+    },
+    "fcae698b41474ab5b9611bf64eb1192f": {
+      "label": false,
+      "text": "Translate the following sentence to Turkish:\nSmoking is still allowed in most cafes in Zagreb. [Davor Konjikusic]",
+      "id": "fcae698b41474ab5b9611bf64eb1192f"
+    },
+    "553c38f4fbc54e699756657b2c5a9bb8": {
+      "label": true,
+      "text": "Dans le bureau de cin\u00e9ma, vous pouvez \u00e9teindre votre musique cellulaire.",
+      "id": "553c38f4fbc54e699756657b2c5a9bb8"
+    },
+    "67f6d03b8bf14d509ad66a0f951fa641": {
+      "label": false,
+      "text": "In week 5, the Lions hosted the Philadelphia Eagles to start a three-game home stand. The Lions took a 14-0 lead in the first quarter with a pair of touchdown catches by Theo Riddick, from one and 17 yards out respectively. The Eagles responded in the second quarter with a one-yard touchdown pass from Carson Wentz to Ryan Mathews, cutting the Lions lead to seven points. The Lions added to their",
+      "id": "67f6d03b8bf14d509ad66a0f951fa641"
+    },
+    "019201c459cd4a0d9f9c2cd23efa6059": {
+      "label": false,
+      "text": "measurement units like miles to kilometers during your translation. 5) Note the input is in sentence case except for special placeholders. Please do the same in your translations.",
+      "id": "019201c459cd4a0d9f9c2cd23efa6059"
+    },
+    "a4b87ff433b443c88b329692b6e217d7": {
+      "label": true,
+      "text": "weg von diesem langweiligen Film --- er ist keinen Cent wert!!!!",
+      "id": "a4b87ff433b443c88b329692b6e217d7"
+    },
+    "6b0d9a26fd6048818ef2349852ef1f7d": {
+      "label": true,
+      "text": "Title: \u0e04\u0e19\u0e41\u0e1b\u0e14\u0e23\u0e34\u0e49\u0e27\u0e44\u0e21\u0e48\u0e40\u0e2d\u0e32\u0e42\u0e23\u0e07\u0e44\u0e1f\u0e1f\u0e49\u0e32\u0e16\u0e48\u0e32\u0e19\u0e2b\u0e34\u0e19\u0e40\u0e02\u0e32\u0e2b\u0e34\u0e19\u0e0b\u0e49\u0e2d\u0e19 \u0e22\u0e31\u0e19\u0e01\u0e23\u0e30\u0e17\u0e1a\u0e40\u0e01\u0e29\u0e15\u0e23\u0e2d\u0e34\u0e19\u0e17\u0e23\u0e35\u0e22\u0e4c \n Body: \u0e0a\u0e32\u0e27\u0e09\u0e30\u0e40\u0e0a\u0e34\u0e07\u0e40\u0e17\u0e23\u0e32\u0e23\u0e13\u0e23\u0e07\u0e04\u0e4c\u0e2b\u0e22\u0e38\u0e14\u0e42\u0e23\u0e07\u0e44\u0e1f\u0e1f\u0e49\u0e32\u0e16\u0e48\u0e32\u0e19\u0e2b\u0e34\u0e19\u0e40\u0e02\u0e32\u0e2b\u0e34\u0e19\u0e0b\u0e49\u0e2d\u0e19 \u0e28\u0e36\u0e01\u0e29\u0e32\u0e1e\u0e1a\u0e2a\u0e32\u0e23\u0e1b\u0e19\u0e40\u0e1b\u0e37\u0e49\u0e2d\u0e19\u0e01\u0e23\u0e30\u0e17\u0e1a\u0e40\u0e01\u0e29\u0e15\u0e23\u0e2d\u0e34\u0e19\u0e17\u0e23\u0e35\u0e22\u0e4c \u0e22\u0e31\u0e19\u0e1b\u0e49\u0e2d\u0e07\u0e1e\u0e37\u0e49\u0e19\u0e17\u0e35\u0e48\u0e2d\u0e38\u0e14\u0e21\u0e2a\u0e21\u0e1a\u0e39\u0e23\u0e13\u0e4c\u0e17\u0e32\u0e07\u0e2d\u0e32\u0e2b\u0e32\u0e23 \u0e41\u0e19\u0e30\u0e43\u0e0a\u0e49\u0e1e\u0e25\u0e31\u0e07\u0e07\u0e32\u0e19\u0e2b\u0e21\u0e38\u0e19\u0e40\u0e27\u0e35\u0e22\u0e19\u0e17\u0e32\u0e07\u0e40\u0e25\u0e37\u0e2d\u0e01 \u0e14\u0e49\u0e32\u0e19\u0e01\u0e25\u0e38\u0e48\u0e21\u0e17\u0e38\u0e19\u0e22\u0e37\u0e48\u0e19 EHIA \u0e23\u0e2d\u0e1a\u0e17\u0e35\u0e48 4 \u0e0a\u0e32\u0e27\u0e1a\u0e49\u0e32\u0e19\u0e19\u0e31\u0e14\u0e23\u0e27\u0e21\u0e15\u0e31\u0e27\u0e23\u0e2d\u0e1f\u0e31\u0e07\u0e1c\u0e25\u0e01\u0e27\u0e48\u0e32 100 \u0e04\u0e19 \u0e2b\u0e25\u0e31\u0e07 \u0e2a\u0e1c. \u0e40\u0e25\u0e37\u0e48\u0e2d\u0e19\u0e1e\u0e34\u0e08\u0e32\u0e23\u0e13\u0e32\u0e40\u0e1b\u0e47\u0e19\u0e27\u0e31\u0e19\u0e17\u0e35\u0e48 23 \u0e21\u0e35.\u0e04. \u0e19\u0e35\u0e49\n\u00a0\n\u00a0",
+      "id": "6b0d9a26fd6048818ef2349852ef1f7d"
+    },
+    "c34863e2f4cc4df798271d25bd15b107": {
+      "label": true,
+      "text": "Einfach nur geil!!! . Diesen Film muss mann einfach gesehen haben!Der 1. Teil war schon lustig bis zum abwinken,aber jetzt der... Und da \"Red Bull\" (auch bekannt aus Hausmeister Krause;Axel Stein) sowieso der beste ist muss man diesen Film einfach gesehen haben!!!",
+      "id": "c34863e2f4cc4df798271d25bd15b107"
+    },
+    "5f59f03d5425404693ac4bbbd9dc9cb9": {
+      "label": false,
+      "text": "Read the following context and choose the correct option to answer the question. Context: Surely the best thing about colomba, the Easter equivalent to panettone, is the sugared, toasted almond topping that covers the whole thing and crumbles when you cut it, so you sort of have no choice but just to pick up the crusty sugary bits and eat those on their own. I\u2019d always thought that colomba would",
+      "id": "5f59f03d5425404693ac4bbbd9dc9cb9"
+    },
+    "cb6ef8e32c9a4daeae95b1be358a34a2": {
+      "label": true,
+      "text": "oameni reactioneaza mai puternic la provocari, informeaza luni Reuters.",
+      "id": "cb6ef8e32c9a4daeae95b1be358a34a2"
+    },
+    "702ddf2463fd481ea7d4bf17e8a4487f": {
+      "label": true,
+      "text": "Write a title for this article:\n\nActualizado nov 16, 2011 6:21 p.m. ET\n\nLa selecci\u00f3n de Uruguay (foto de archivo) cerro con broche de oro el 2011, a\u00f1o en que gan\u00f3 la Copa Am\u00e9rica y alcanz\u00f3 el cuarto lugar en el ranking de la Fifa. (AFP)",
+      "id": "702ddf2463fd481ea7d4bf17e8a4487f"
+    },
+    "733cdb5aada7496da5a3e0c0b58104ef": {
+      "label": true,
+      "text": "et Vikas Swarup a sa mani\u00e8re \u00e0 lui de raconter l'histoire. Mine de rien, au gr\u00e9 des balades de Ram, on apprend (beaucoup) sur l'histoire de l'Inde, Bollywood, le Taj Mahal, le sport, et une quantit\u00e9 de choses. A chaque flashback, on se demande \"qu'est-ce qu'on va apprendre ce coup-ci ?\" et je m'amusais \u00e0 me dire \"tiens, la prochaine question, ils parleront de \u00e7a !\". Je me trompais une fois sur",
+      "id": "733cdb5aada7496da5a3e0c0b58104ef"
+    },
+    "f86f0217ba544366a1757c4da78f70ab": {
+      "label": false,
+      "text": "He hoped they would not need him. The church would pay his regular part-time salary while he was serving on a jury, but any private lessons he missed would be money lost. Greg's red 1965 Pontiac Bonneville convertible always turned heads as he drove through the small town. He had purchased it two months earlier from a career Navy man down in Longview who had babied the thing for years. It spent",
+      "id": "f86f0217ba544366a1757c4da78f70ab"
+    },
+    "e09b26ee3d0a4622ac6d96d32ccb60ab": {
+      "label": true,
+      "text": "Write a title for this article:\n\nSaturday, November 22nd 2008, 4:00 AM\n\nMIAMI \u00e2\u0080\u0094 Ha sido un parto muy lento ... el m\u00c3\u00a1s lento que haya tenido Laura Restrepo para alumbrar alguno de sus libros.",
+      "id": "e09b26ee3d0a4622ac6d96d32ccb60ab"
+    },
+    "12555f602cb34c6e9388340f3291740b": {
+      "label": true,
+      "text": "Puoi usare un triangolo per produrre musica.\n",
+      "id": "12555f602cb34c6e9388340f3291740b"
+    },
+    "eb28652669174d5a952e820c0a31dc3f": {
+      "label": false,
+      "text": "if there's a program near you. Washing multiple small loads of laundry in your washing machine wastes both water and energy. Setting your machine to the appropriate load size can reduce water waste. Grease can seriously clog up your pipes and add to the scum levels in your septic system. Don't pour grease down the drain. Instead, pour it into a separate container and throw it away in the trash.",
+      "id": "eb28652669174d5a952e820c0a31dc3f"
+    },
+    "5c566f7b0a1d4cb2813c102e64094392": {
+      "label": false,
+      "text": "adopted by various branches of the church, often referred to as \"subordinate standards\". It is generally considered that the point of such learning is to enable one to put one's faith into practice; some Presbyterians generally exhibit their faith in action as well as words, by generosity, hospitality, as well as proclaiming the gospel of Christ.\". Can you tell me what it is?",
+      "id": "5c566f7b0a1d4cb2813c102e64094392"
+    },
+    "6d4119f5ae80413a9e79c14ad4d21bda": {
+      "label": false,
+      "text": " \u201cThere is no relationship between this woman and Salvador Dal\u00ed,\u201d he told Spanish agency Efe at the time. ||||| A judge has ordered the exhumation of Salvador Dali's body for a biological test to determine the paternity of Maria Pilar Abel Martinez, 61, who claims to be his daughter. The order came from a Madrid judge who said the measures were \"necessary\" because \"there are no biological remains",
+      "id": "6d4119f5ae80413a9e79c14ad4d21bda"
+    },
+    "dbc88798632c4ff98799907a94b3896b": {
+      "label": true,
+      "text": "pintura que el film hace del dolor de crecer en la horfandad, tanto f\u00edsica como espiritual.",
+      "id": "dbc88798632c4ff98799907a94b3896b"
+    },
+    "d04570f03fec4569ae019a1a76fd5b45": {
+      "label": false,
+      "text": "plugged in an address and then set off to their destination. And, then it wasn't until they were driving for thirty minutes that they realized they actually put in a destination back on the West Coast where they lived. They actually put their home address in. So again, the GPS is kind of 'garbage in garbage out'.\" Mister Brown says this is a common human error. But, he says, what makes the problem",
+      "id": "d04570f03fec4569ae019a1a76fd5b45"
+    },
+    "49c85f4e2ffd4ee688db1cf747bc7ce1": {
+      "label": false,
+      "text": "in which he was played by Cesar Romero. The show's popularity compelled Schwartz to keep the comics in a similar vein. As the show's popularity waned, however, so did that of the Batman comics. After the TV series ended in 1968, the increase in public visibility had not stopped the comic's sales decline; editorial director Carmine Infantino resolved to turn things around, moving stories away from",
+      "id": "49c85f4e2ffd4ee688db1cf747bc7ce1"
+    },
+    "235a4b30f15a4d0d85f560e12239fdd1": {
+      "label": true,
+      "text": "QUESTION: \u00bfPor qu\u00e9 ped\u00eda esa compensaci\u00f3n econ\u00f3mica la pol\u00edtica colombiana?\nA:",
+      "id": "235a4b30f15a4d0d85f560e12239fdd1"
+    },
+    "73881faa52944be08a4367ff818df4db": {
+      "label": true,
+      "text": "  \n Add this video to your website by copying the code below. Gehiago jakin \n  \n Hmm, arazo bat egon da zerbitzariarenera iristeko. Berriro saiatu? Gehitu Txio gurasoak Media gehitu \n  \n Zure webgunean edo aplikazioan Twitter-eko edukia kapsulatzean, Garatzaile Akordioa eta Garatzaile Politika onartzen dituzu. \n  ",
+      "id": "73881faa52944be08a4367ff818df4db"
+    },
+    "c639bba0bb6c48e6959645356d967e5c": {
+      "label": false,
+      "text": "Summarize this article:",
+      "id": "c639bba0bb6c48e6959645356d967e5c"
+    },
+    "543ac52d22514df98edf1ad77cfc6280": {
+      "label": true,
+      "text": "Q: CONTEXT: El vicepresidente segundo y ministro de Econom\u00eda y Hacienda, Rodrigo Rato, reconoci\u00f3 hoy que el Gobierno conoc\u00eda \"hace tiempo\" los planes del BBVA y Telef\u00f3nica de firmar una alianza estrat\u00e9gica, pero asegur\u00f3 que no impuls\u00f3 la operaci\u00f3n. En unas declaraciones a los periodistas antes de visitar la feria de arte Arco, Rato afirm\u00f3 que, en contra de lo que suced\u00eda durante la Presidencia de",
+      "id": "543ac52d22514df98edf1ad77cfc6280"
+    },
+    "35fde42dab104edd9b9e8dbfa976ae97": {
+      "label": true,
+      "text": "\u0e22\u0e01\u0e07\u0e32\u0e19\u0e27\u0e34\u0e08\u0e31\u0e22\u0e0a\u0e35\u0e49\u0e2a\u0e32\u0e23\u0e1b\u0e23\u0e2d\u0e17\u0e2a\u0e48\u0e07\u0e1c\u0e25\u0e15\u0e48\u0e2d\u0e2b\u0e48\u0e27\u0e07\u0e42\u0e0b\u0e48\u0e2d\u0e32\u0e2b\u0e32\u0e23 \u0e1e\u0e31\u0e12\u0e19\u0e32\u0e01\u0e32\u0e23\u0e2a\u0e21\u0e2d\u0e07",
+      "id": "35fde42dab104edd9b9e8dbfa976ae97"
+    },
+    "96da755c0d6c4f3ab3b8f34b925f1ffc": {
+      "label": true,
+      "text": "/><br />Do watch this movie!!! a Total Masala Flick and Enjoyable Family Film!<br /><br />OYE AAJA NACHLE!!!!!!!!",
+      "id": "96da755c0d6c4f3ab3b8f34b925f1ffc"
+    },
+    "f758b25d05c043dcbf3df2c6b9f56705": {
+      "label": false,
+      "text": "first day of its release and v both get bore in cinema-hall......................................................<br /><br />Role of CIRCUIT was very small n useless n this movie . I think SANJAY-DUTT cut down the role of ARSHAD VARSHI........................<br /><br />Character of the movie is also not well define like the previous one .this movie show u the result of OVER-CONFIDENCE",
+      "id": "f758b25d05c043dcbf3df2c6b9f56705"
+    },
+    "50bb7f2fa5b14c139badd2be2a13bcda": {
+      "label": false,
+      "text": "is the emotion, and Hache is the doubt. And here they are mixed in Spain at the end of twentieth century.<br /><br />The performance is simply wonderful. Cecilia Roth (All about my mother) is splendid and what can i say about Federico Luppi who is one of the best actors in Spanish language that exists. I can imagine nobody except Eusebio Poncela as Dante. Juan Diego Botto is quite good.<br /><br",
+      "id": "50bb7f2fa5b14c139badd2be2a13bcda"
+    },
+    "82ad499ab5494feeb9f35444a29a8f0f": {
+      "label": false,
+      "text": "NOTICE: I do touch on the plot, but not so as to spoil the movie...<br /><br />This long and sensuous movie set in 1942 Shanghai during the Japanese occupation is centered on a beautiful and elegant young woman Wong Chia Chi (played by newcomer Wei Tang) who - with her platonic friend Kuang Yu Min (played by Chinese male hottie Lee-Hom Wang) - is a willing participant in a group of 6 young actor",
+      "id": "82ad499ab5494feeb9f35444a29a8f0f"
+    },
+    "ec3ea869f1444df1aa91a47e4eeb4bb2": {
+      "label": false,
+      "text": "This is the best movie ever! Don't miss out on it! Vivek Oberoi and Rani Mukherjee have done SUPERB EXCELLENT acting!! The story, its not really very special or unique but the way Vivek and Rani have acted, it seems even better. So if you haven't seen it yet, go see it right now. This isn't something to be missed!!!!!!!!!!!",
+      "id": "ec3ea869f1444df1aa91a47e4eeb4bb2"
+    },
+    "07579e0ceaed429bacce1dcaefa73980": {
+      "label": false,
+      "text": "of 10. Feel free for mailing me about any of my comments and posts here. <br /><br />Sorry for my bad English.",
+      "id": "07579e0ceaed429bacce1dcaefa73980"
+    },
+    "1a2d210ee30f4a3d84ec6d0f4ef77f1c": {
+      "label": false,
+      "text": "and the argument with hirko in the walkway with a roof on it???? need to know so I can win an argumrnt with me Japanese ex-wife. thanks",
+      "id": "1a2d210ee30f4a3d84ec6d0f4ef77f1c"
+    },
+    "ae005e1fadd546cbb82b733e6d68edad": {
+      "label": false,
+      "text": "conclusion packs a mean and lingering wallop right to the gut. A solid and satisfying winner.",
+      "id": "ae005e1fadd546cbb82b733e6d68edad"
+    },
+    "7c116c5decaf4e65a89405aed0277ccc": {
+      "label": true,
+      "text": "\"Como Era Gostoso o Meu Franc\u00eas\" (\"How Tasty Was My Frenchman\")",
+      "id": "7c116c5decaf4e65a89405aed0277ccc"
+    },
+    "6006ace2058742d3b776274e5334f613": {
+      "label": false,
+      "text": "song for kids (I think... it could also be south American, I'm not sure)). This two songs that have the same melody... but people don't usually realize that... it's just grate! I tried to write this in both Spanish and English, because it's an Argentinian movie... but the page wouldn't allow me :( Hope you enjoy it!",
+      "id": "6006ace2058742d3b776274e5334f613"
+    },
+    "ded4f2384df44b22a4425312aaea3499": {
+      "label": true,
+      "text": "is biased in favour of Chavez, nothing's stopping you from doing your homework. One crucial message of the film is questioning info sources, as was clearly demonstrated by the snippers casualties being shamefully blamed on Chavez's supporters. Venezuela puts American alleged democracy to shame. Hasta la revolucion siempre!",
+      "id": "ded4f2384df44b22a4425312aaea3499"
+    },
+    "b393f9b5c01b4388af5f9c8a1fa70843": {
+      "label": true,
+      "text": "(Brazil): \"Invas\u00e3o de Domic\u00edlio\" (\"Invasion of Domicile\")",
+      "id": "b393f9b5c01b4388af5f9c8a1fa70843"
+    },
+    "95cc03b8508b44a18a4aee4b27743f1f": {
+      "label": false,
+      "text": "/><br />PS: tried to write in Spanish but the system does not accept it!",
+      "id": "95cc03b8508b44a18a4aee4b27743f1f"
+    }
+  },
+  "version": 189,
+  "description": "Text that contains non-English."
+}

lilac/concepts/positive-sentiment/concept.json

@@ -0,0 +1,564 @@
+{
+  "namespace": "lilac",
+  "concept_name": "positive-sentiment",
+  "type": "text",
+  "data": {
+    "0": {
+      "label": false,
+      "text": "Starting To Be Annoyed By Becky...: I'm not sure why I keep reading these books, but I guess it's because I've read the first two so I'll keep reading the rest of the books. In the first book, I really found it amusing. I was a little annoyed by the fact that Becky couldn't stop spending, but then again that's why she is called a Shopaholic. In the second book, I felt more of the same it was just magniifed more. Now in the third book, I'm just down right annoyed by Becky Bloomwood. In this book, she wasn't going on crazy shopping sprees, just planning two different weddings because she was afraid to tell each person and because I feel she's really selfish. Still, I read the book because I wanted to see how she could get herself out of another situation. I will say that I love her friends Suze and Danny, her client Laurel and her husband Luke. Maybe that's why I keep reading. I will read the next book, but I'm sure I'll be just as annoyed when I'm done.",
+      "id": "0"
+    },
+    "1": {
+      "label": false,
+      "text": "the cover is fine - the pool is horrible: The entire pool was horrible. The cover was fine once we got it on, but we finally got rid of the pool after 2 weeks because it was so hard to set up and keep clean.",
+      "id": "1"
+    },
+    "2": {
+      "label": true,
+      "text": "Good album, not their best.: This album is probably the most marketable and radio friendly of all of dashboard's albums. For the peripheral listener it may be the right one to get to introduce you to this band. But as a Dashboard fan of 5 or so years I truly hope they return to their original sound for their next work. Not for the listen-ability but for the show. To this day the fans react best to the songs from \"Places\" or \"A Mark, A Mission.\" I recommend this album to everyone but I also recommend any and all of their other work.",
+      "id": "2"
+    },
+    "3": {
+      "label": false,
+      "text": "This is a horror novel, right?: Never one to pass up any vampire novel, I purchased Sips because the description seemed interesting. Vampires, Marquis de Sade, fetishism, yada yada yada. If this is a comedy, I give it 4 stars; however, I'll give it 1 star as a horror novel. Sade was rather boring; I would think a character as intense and multi-faceted as the Marquis de Sade would make for a more interesting vampire. The writing style isn't too bad, but overall I found the characters to be mildly amusing at best. The plot was thin, the end was anti-climactic, and the vampires were not very frightening. The book had little suspense, and it leaves a mile-wide opening for a sequel at the conclusion. I would, however, like to see something more of the vampire mutants lurking in the graveyard. They were the most riveting of any of the characters.",
+      "id": "3"
+    },
+    "4": {
+      "label": true,
+      "text": "Superb mix of global non secular musical denominations: I first heard Ms. Pook's music on the \"Eyes Wide Shut\" soundtrack (the masquerade ball scene) and was blown away; if ever there was a necessity for music to permeate a scene in a film this was it. She incorporates a blend of the traditional songs from faiths across continents and mixes them, for lack of a better comparison than similar to your quintessential raver d.j. (though these are better and definitively more original :) \"Oppenheimer\" is my favorite, and if you let the last track run for a few minutes a portion of the song will play once more. I can't wait to hear more of her stuff - these hymns are awesome.",
+      "id": "4"
+    },
+    "5": {
+      "label": true,
+      "text": "A moving and suspenseful story!: For anyone familiar with the occult, this book is likely to raise hairs on the back of your neck as you read. Even if you're not, the storyline is suspenseful and fascinating, and the characters evoke great sympathy and admiration. An excellent read.",
+      "id": "5"
+    },
+    "6": {
+      "label": true,
+      "text": "Simple & Easy to Use - A Practical approach to eating out: This guide is extremely to use. It provides sample menus that you'd see at Chinese, Indian and Thai restaurants. Then you are provided with descriptions of each dish and how it is prepared and the ingredients used. From there you are provided with specific considerations as to how the preparation or ingredient list may affect you if you have Gluten or Allergen issues.This book is the size of a passport and very organized and well written. The Chinese, Indian and Thai Cuisine Passport is perfect for making choices while traveling, or while dining at your favorite local restaurant.",
+      "id": "6"
+    },
+    "7": {
+      "label": false,
+      "text": "Being Fair....I am a fan of hers: and I really enjoyed her previous works, more than I could have ever imagined, but this record is horrible. The songs are trite, the lyrics are incredibly boring, indulgent and immature. The music is pop staple, with forgetable melodies and repetative chorus lines, I feel as if the studio wrote the entire album for her while she was sleeping, this just doesn't speak to any of her previous works at all. This album fits on the same shelf with a Nickelodeon-themed CD. Instead of heading in the direction of an artist like Alanis Morrisette, she is going backward and joining the ranks of Hannah Montana and the Naked Brothers Band. She is a great artist and her first two records are amazing. She is better than this CD and I am looking forward to her next effort.",
+      "id": "7"
+    },
+    "8": {
+      "label": false,
+      "text": "Sucked: I thought the DVD sucked tremendously. It was very boring and if I could, I would return it for a refund. There was only one \"small\" clip of Dylan himself. I'm very disappointed.",
+      "id": "8"
+    },
+    "9": {
+      "label": true,
+      "text": "Excellent product: Easy to install. If you have a newer furnace you probably do not need the swail switch as the HE220A comes with a Humistat which can be connected to the furnace. They recommend the Honeywell 32005847-001 Installation Kit, Bypass which is a little pricey and you can probably buy the pieces of this kit cheaper individually from Home Depot or Lowes or ACO as well as the filters.",
+      "id": "9"
+    },
+    "10": {
+      "label": true,
+      "text": "Very happy.: I am very happy with this trashcan. I was unable to find one in the stores to fit the space in my cabinet, but this one does the job. It is very sturdy and looks like it will put up with years of use.",
+      "id": "10"
+    },
+    "11": {
+      "label": false,
+      "text": "These aren't Throughbreds!: This makes me so mad. All these new authors are coming and changing the series. Nothings the same anymore and the plots are repeditive. Don't even bother reading these books until #32 these are like a different series. I don't know excactly what's happing but these new authors suck!",
+      "id": "11"
+    },
+    "12": {
+      "label": false,
+      "text": "Large and slow are a bad combination.: I bought this TV and returned it a week later, because it blurred so badly with motion that sports were unwatchable. I ended up buying a smaller Sony XBR4, and I have none of the issues (plus the picture is far, far better).This has nothing to do with 60 vs 120Hz. That is more important for DVDs and Blu-Ray signals that are 24fps (which doesn't divide evenly into 60 but does for 120). The LT52133 has an 8ms response time, which is extremely slow. A decent LCD should be 5 or lower.If you want an LCD, choose speed and quality over size. If you want size and quality but want to spend less, buy a plasma. Don't buy a big, cheap, slow LCD!I gave it 2 stars because I like the interface and remote.",
+      "id": "12"
+    },
+    "13": {
+      "label": false,
+      "text": "Skip it: This movie is very poorly written and the result is not distressing, just lame. The actors do their best but from very early on it is obvious that the material gives them nothing to work with. Fans of Colin Firth will experience a certain dim level of enjoyment. Minnie Driver is a treat but her character is no better written than the others. Vermont locations are worth something. With one or two moments of exception it's neither comedic nor romantic.",
+      "id": "13"
+    },
+    "14": {
+      "label": true,
+      "text": "Belive it i went to the concert?: hi everyone let me tell you i went to the concert i was amazed with what i saw cher was awsome i tell you buy the dvd. as i sat in front of the stage cher was doing a great job to us the she is living proof . So i urge you to buy it?",
+      "id": "14"
+    },
+    "15": {
+      "label": true,
+      "text": "Vale la pena.: En este libro se narra de una forma muy interesante la vida de una familia en particular. Lo que mas me gusto de este libro fue la manera en que la autora describe a lo largo del libro las personalidades de los sujetos envueltos en la novela; que vienen a ser muy distintos y extremos, lo cual, intensifica el drama... Definitivamente es un buen libro y lo recomiendo a todos.",
+      "id": "15"
+    },
+    "16": {
+      "label": true,
+      "text": "Nummie Children's story: I ordered this book for our grandchildren. Two boys 5 & 3 and a 4 month old girl. All love the story. The mouse is determined.",
+      "id": "16"
+    },
+    "17": {
+      "label": false,
+      "text": "Seem to be alone on this one: Looking at the other reviews, I seem to be the only one that was disappointed with this book. The content is too babyish in most of it for older tweens and the more \"grown up\" content would be over a younger tween's head. I had a quick read through and with every paged turned, I thought duh. I'll be looking around for another book shortly.",
+      "id": "17"
+    },
+    "18": {
+      "label": true,
+      "text": "Best yet: by far the best EA game yet. I especially like the easy controls and kick - a graphics. the playbook is extremely accurate and detailed. Also the fight songs and cheerleaders were a nice touch. this is an excellent game and worth checking out.",
+      "id": "18"
+    },
+    "19": {
+      "label": false,
+      "text": "washed out: A bit like Simply Reds version of the Valentine bros hit \"Moneys too tight to mention\" - this cover version has nothing of the driving energy that characterised the original recording.",
+      "id": "19"
+    },
+    "20": {
+      "label": true,
+      "text": "great water bottle: I love this bottle it is great. I like knowing it is non toxic and it just works very well. You can have it full and lay it down and it doesn't leak at all.",
+      "id": "20"
+    },
+    "21": {
+      "label": true,
+      "text": "Nice goggles: I am pretty happy with these goggles. They work well during swim workouts in the pool. I do notice a little bit of fogging from time to time. I had hoped to wear them during an upcoming triathlon, but based on a few instances where they slipped a little in the pool I am concerned that they won't be secure enough. I will keep using them in the pool, but will likely get different ones for open water races.",
+      "id": "21"
+    },
+    "22": {
+      "label": false,
+      "text": "aaahhh nnnoooooo!: Hopefully the last film in one of the worst horror trilogys ever made. This series pretty much ruined the horror film for years to come, for one its too self aware, thats incredibley annoying, second everyone acts like they are on Friends or some sitcom. The acting is just plain bad and unconvincing. Now the gore, if you're going with material this weak you should load it up with disgusting violence, is there any in the Scream series? No.Everyone went to see this movie just to see who THE KILLER is. This movie sets low standards to be met, you expect alot of people to die, one shock, then we find out who the killer is, then you go home. Every horror film being made today is like that, there's nothing new or exciting or risk taking, its the same stuff over and over and people are laping it up like dog food.This film is what you've come to expect, bad acting, some people die and we eventually find out who the killer is and all is merry and well. Pathetic.",
+      "id": "22"
+    },
+    "23": {
+      "label": true,
+      "text": "A classic of its kind: This movie is a classic of its kind and much better that a lot of movies, that followed. It is not one of the best, but it still deserves five stars...",
+      "id": "23"
+    },
+    "24": {
+      "label": false,
+      "text": "Nice suite, but Virtual PC 7 disappoints on my G5: I purchased the upgrade since I'd already bought both Office v.X and Virtual PC 6.1 last year.The biggest letdown is that Microsoft's promised support for the G5 is nearly non-existent. I have a dual processor G5 with an ATI Radeon 9800 card (Apple), and after trying to install Virtual PC 7 three times, I cannot get a VM to work. It did install (and work) flawlessly on my G4 Powerbook. Googling for reviews finds it's very hit or miss, but if (when) it misses, you'll regret investing the extra $$$ in an immature product.",
+      "id": "24"
+    },
+    "25": {
+      "label": false,
+      "text": "Okay player, don't expect a miracle: I bought this DVD player at Circuit City earlier this yr for about a $100. I hooked it up to a 47\" Vizio LCD (which by the way has an awesome picture) using a HDMI cable. After fine tuning this product, I was very, very, very diasppointed. The picture was very \"grainy\" (lots of pixels). I have a $35 DVD player that only utilizes an s-video cable that produces a much more crisp picture. Be warned, the picture stinks.",
+      "id": "25"
+    },
+    "26": {
+      "label": true,
+      "text": "A revelation of the science of consciousness evolution and all natural growth: Here is a readable and fascinating account of the development of the new science of chaos theory, the only body of ideas that describes how the natural world as experienced by human beings emerges out of basic quantum processes. The different explorers and innovators of the new science are introduced in a personable way that will enchant the interested reader.",
+      "id": "26"
+    },
+    "27": {
+      "label": false,
+      "text": "Don't say that I didn't warn ya' !: I'm absolutely convinced that Delbert McClinton had no controlover the release of this CD. I rated it 1 star simplybecause there is no 0 star rating ! In actuality , I am not certain that the vocalist on this recording IS Delbert McClinton. Only on the Mr. Pitiful track is there any similarity at all to Delbert's voice. This is the perfect CD for someone with money to burn who would like to have a recording of a 1960's garage band recorded in a garage and who should be working in a garage ! Delbert fans...run fast and run far away from this ! END",
+      "id": "27"
+    },
+    "28": {
+      "label": false,
+      "text": "This item is not available: I ordered this unit on February 7th. Every time I checked back on the status of the order, it read \"not shipped\" and the estimated shipping date got moved out. I really don't think this unit is avaialble from the company anytime soon. I cancelled the order.",
+      "id": "28"
+    },
+    "29": {
+      "label": false,
+      "text": "I used to like ABBA...: I used to like ABBA, until I saw Mama Mia! A horribly disjointed musical, where songs feel contrived to fit into the story; a story that doesn't seem to come together. Individual songs are usually done alright, but don't segue from one to another very well.The cast butchered several of the songs, but especially S.O.S, Take A Chance On Me, and anything where Pierce Brosnan sang. On a side note, I also counted at least two violations of Chekov's Gun. And finally, I think it has a bad moral message. Which you only recognize if you manage to sit through the whole thing.If there is justice in the world, cast members without established careers won't get to have them as punishment for the worst movies I've seen since The Talented Mr. Ripley.",
+      "id": "29"
+    },
+    "30": {
+      "label": false,
+      "text": "A complete disaster!: If you're like me, you probably wanted to check out this movie because it sounded like it really could be an excellent supernatural Gothic horror tale full of goblins and wicked things alike. Well, don't make the same mistake I did and actually watch it. It's horrible. Terrible. An honest to goodness waste of film. The acting is wretched, the film quality is rotten (it actually looks twenty years older than it is), and the plot is thin, weak, and does not give you what it's supposed to. The only reason I bothered to give this film 1 star is because of Alexis Arquette -- he's great looking, but should have left this film out of his career.",
+      "id": "30"
+    },
+    "31": {
+      "label": true,
+      "text": "beautiful detail: I just purchased these Dover COloring Books for my mother and she loves them. The detail is out of this world and the variety of colors you can use are only limited by your inagination. HIGHLY RECOMMENDED!",
+      "id": "31"
+    },
+    "32": {
+      "label": false,
+      "text": "Very disappointed: I looked forward to getting this movie as I had heard many good things about it but it was nothing like I had imagined or been led to believe. There is very little actual history in it or real Christian experience except for the background because the main focus is a soap opera style romance and caricature figures. I agree with the reviewer who described it as a mixture of \"tawdry Hollywood sex\" somehow interspersed with a vague nod to Christianity. The only decent scene was the arena scene where the Christians are going to their deaths singing hymns - but that's not enough to make it a great or even a good movie. Not personally to my taste anyway.",
+      "id": "32"
+    },
+    "33": {
+      "label": false,
+      "text": "Unreliable minikit: I bought this minikit because it got good reviews and it would be perfect for my purposes. However it switches on and off whenever it wants, it looses contact with the phone. Very often the on/off button works only in a horizontal position (?) I use a Treo 650, which is on the compatible phone list. When I contacted Parrot, they said it wasn't (?) At last I opened the unit, but there are no moving parts inside except the micro switches. It is giving me a headache, so I will go searching for an alternative.",
+      "id": "33"
+    },
+    "34": {
+      "label": true,
+      "text": "A Christmas Classic!: This is surely one of the best classical Christmas recordings available. Don't buy the older version, as the quality of this recording is excellent. This is one of those \"Every Christmas - Can't have Christmas without\" recordings.",
+      "id": "34"
+    },
+    "35": {
+      "label": false,
+      "text": "too narrow: These were the narrowest pair of D size shoes I have ever tried on. I don't care how nice a shoe looks. If it don't fit it just don't fit.",
+      "id": "35"
+    },
+    "36": {
+      "label": false,
+      "text": "Lack of extension: This earphones lack a descent extension cord. ITs very small cable, but its of good quality. Sadly, cord its too short, and the extension is useless.",
+      "id": "36"
+    },
+    "37": {
+      "label": true,
+      "text": "Easy-Reading: This is the 3rd Southern Sisters Mystery I've read. They're easy, fast and funny murder mysteries, with lots of cute family stories intertwined in the intrigue.",
+      "id": "37"
+    },
+    "38": {
+      "label": false,
+      "text": "it'd be great if it worked like it was supposed to: for the first 30 seconds it was lovely, but i believe that either the motor isn't powerful enough to keep the shaft rotating smoothly or 3 AA batteries just don't provide enough juice for the motor to work more than 30 seconds. it was a nice idea, but i'm rather dissapointed. the jelly material is somewhat difficult to maintain also. i think if it were hooked up to a larger battery pack it'd be WONDERFUL... which i think i may have a macgyver friend with a knack for electronics attempt to do for me.",
+      "id": "38"
+    },
+    "39": {
+      "label": true,
+      "text": "Not Hornby's best but still good: I loved About a Boy and really, really loved the sardonic wit of High Fidelity. About a Boy is much deeper but just as cynical. Maybe even more so. The characters are richly drawn and just complex enough to keep the reader wanting more. Good read, but best to take some time with this one. Not recommended for a summer beach read.",
+      "id": "39"
+    },
+    "40": {
+      "label": false,
+      "text": "A Disappointment: As with most Taunton Press publications, the illustrations and photographs in this book are spectacular and the organization and layout is superb. Nonetheless, I found this book disappointing. It lacks both depth and breadth. I had hoped for a detailed review of wood joinery including some of the more unusual joinery found in Japanese woodworking. This book, however, is targeted more toward the beginner. Even so, it does not cover the details and \"tricks\" of even the most basic techniques in sufficient detail to allow beginners to easily reproduce them. Consequently, it is unclear who this book was written for - not the beginner as it lacks depth, and not the advanced woodworker as it lacks breadth. Far more effort appears to have been put into appearance and organization than in content.",
+      "id": "40"
+    },
+    "41": {
+      "label": false,
+      "text": "Horrible. Don't do it!: Great price for the item when a 6' one of these at Best Buy is $20. Thing is, the one from Best Buy fits in the outlet and stays there. This cord fits very loose and does not connect. I bought 2 of them, neither did what they were suppose to.As much as I hate to say it, but, buy the more expensive one. At least it works.",
+      "id": "41"
+    },
+    "42": {
+      "label": true,
+      "text": "Given as a gift...: Given to my best friend as a gift. She loves it. Her fiance enjoys making coffee for her in the mornings. :)",
+      "id": "42"
+    },
+    "43": {
+      "label": true,
+      "text": "Love the ring.: This is a nice ring. I was worried it out be thin and cheap looking, but it's not. It's a very pretty stylish ring. Go for it.",
+      "id": "43"
+    },
+    "44": {
+      "label": false,
+      "text": "Beautiful writing Marred by One-Note Characterizations: How could Kingsolver have ruined her book with such an obvious error? Nathan is a strident paper doll that flattens the whole story. Just as bad, the author has all the narrators using the same ironic tone to decribe him, deadening their voices as well. At the same time, Kingsolver doesn't have the guts to show him doing something trully terrible. I don't trust an author who can't let the reader make up his own mind, and as a consequence I couldn't trust her views about ANYTHING in the story. I'm giving this two stars for her descriptions of the African landscape, and that is all.",
+      "id": "44"
+    },
+    "45": {
+      "label": false,
+      "text": "Much worse than any cordless phone I've ever had: This phone cuts out only 2 rooms away from the base station. There is static noise, and callers on the other end complain about sound quality. I can't go into the garden, which used to be no problem with my old 900 MHz phone.",
+      "id": "45"
+    },
+    "46": {
+      "label": false,
+      "text": "Waste of time & money: The first Hangover was not too bad, this one was just terrible. The acting is bad, the script is bad, everything about this movie was just bad. Do yourself a favor, don't buy this movie as it is a total waste of time and money.",
+      "id": "46"
+    },
+    "47": {
+      "label": false,
+      "text": "Did Not Work For Me!: Impressive You Tube Video (Like a Sci-Fi Fantasy). In reality it's a high speed Easy Out so unsurprisingly it broke faster than an Easy out. This product did not work for me. The drill part did not drlil, the puller part did not pull. It was a total zero.",
+      "id": "47"
+    },
+    "48": {
+      "label": true,
+      "text": "Excellent book, long overdue.: From a very long time women were told that looking good was of utmost importance. This was without regard to health or fitness and how age affected these parameters. Witness the whalebone and other types of corsets, the spike heeled shoes and the numerous weight loss programmes on the market (some of which are downright dangerous). Now there is a book, backed by solid research, that allows women of all ages to remain fit and healthy for a lifetime. I am certainly going to recommend this book to all the women I know.Bentley Norville",
+      "id": "48"
+    },
+    "49": {
+      "label": false,
+      "text": "not an all star: Not a practical guide in this collecting age. Does NOT have a comprehensive list; meaning it does NOT cover all manufacturers and, more importantly, for the ones it does, only provides listings of the base set. That means no insert or variation pricing whatsoever. Also, no oddball or minor league issues are listed. Generally speaking, unless you are collecting base sets prior to the advent of inserts and alternate versions of the base set, this guide is fairly useless.",
+      "id": "49"
+    },
+    "50": {
+      "label": false,
+      "text": "Again, second rate city, third rate writer: Just another example of Mr. Lindberg's pitiful attempt at exhibiting a strong expertise on a subject with which he is clearly obsessed. Don't waste your time with this book, either. It is poorly written and fails to engage the reader. You might consider using this book and the first book he wrote on the same subject, as a pair of bookends. That is about all they are worth.",
+      "id": "50"
+    },
+    "51": {
+      "label": true,
+      "text": "Reality: No one should need to convince you to buy this book, you should just do it! It's so well written and worded and brings you right to the heart of a sexual reality that most people like to pretend doesn't really live and breath in their fair cities. I never again want to hear someone bad mouth a working girl for what she does. I will and do now however look at men with a curious eye wondering if they are depraved peep show window lickers :)",
+      "id": "51"
+    },
+    "52": {
+      "label": false,
+      "text": "Bummer: Visual effects and Battle footage were great...the other 85% of the movie was just lousy fluff...",
+      "id": "52"
+    },
+    "53": {
+      "label": true,
+      "text": "The spark of idependence: Filled with the independent spark that made us all love life at one point or another. A fun, introspective and nonsensical movie that sticks with you.",
+      "id": "53"
+    },
+    "54": {
+      "label": true,
+      "text": "What I expected from Mirman's website. Funny. Funny. Russian.: lol, gotta love Eugene. Even when his audience doesn't initially laugh, he gets in a good zinger at himself and they laugh at that. He's witty without being condescending, and uncomplicated without seeing contrived. However, if you're not a fan of irreverant humor, this may not be for you.",
+      "id": "54"
+    },
+    "55": {
+      "label": false,
+      "text": "Do not...repeat...do not bother!: It is not often that I offer a negative review but this compilation while attractive does not deliver at all.The foot massage gizmo is awkward and uncomfortable.The pumice stone leaves rough splinter like skin.The foot scrub doesn't reall scrub.The rotary action tool has five heads, none of which work well and you must hold the switch in place or it turns off. It is cumbersome and ineffective.The one star was initially given for a foot brush (which later lost its bristles very easily as I update the review) and a sweet smelling foot repair balm.Don't waist your money. Soak your feet and invest in an inexpensive German Titania file, smooth and coarser side, or a like product. It will last for years.",
+      "id": "55"
+    },
+    "56": {
+      "label": false,
+      "text": "Not Sandra's Best: Ms. Brown has written better romance novels. Don't give up on her if this was your first Sandra book.The feeble female lead struggles with a 15-year crush that walks back into her life. The smug male lead acts like a jerk through most of the novel. The romance scenes grapple to muster up passion but fall short. Both of the main characters bothered me; my favorite character was the 17-year old.A quick read...about 4 hours (with interruptions) for me...but probably not worth it.",
+      "id": "56"
+    },
+    "57": {
+      "label": true,
+      "text": "Impressed: Lots-O-Fun. Wood and glass toys are high quality and are a good fall back for the kids to play with they are \"bored\". Would buy again.",
+      "id": "57"
+    },
+    "58": {
+      "label": false,
+      "text": "Light turned on by itself 3 times: The installation was easy. I used it for a week, everything worked fine, EXCEPT the light it connected to turned on by itself 3 times so far, with no one near to either one of the switch. Not sure whether it is a defective unit, or this product is too sensitive to noise. I'm returning this product and will just install a regular switch instead.",
+      "id": "58"
+    },
+    "59": {
+      "label": true,
+      "text": "good battery: I feel kind of silly writing a review for a battery, but have to say that these last a LONG time. Work very well.",
+      "id": "59"
+    },
+    "60": {
+      "label": true,
+      "text": "Even a Woman finds it funny: Yes, even a woman finds \"Married to Mommy\" funny. The book gets you laughing aloud when it is trying to make fun of \"Mommies\". The truth is that it really is making fun of the stupidity of men and their simple basic needs of sex, getting out of work, and beer. Of course, the truth is always funny.A definite MUST for any woman, married or not. We will now know all the secret tricks the men try to use on us.By the way, I am NOT a MOMMY!",
+      "id": "60"
+    },
+    "61": {
+      "label": true,
+      "text": "Gungrave...not quite what you might expect: Those thinking this is another version of Trigun will be disappointed. Gungrave is actually a lot deeper and more complex. The lead is short on dialouge, but the story has more depth and character development than most anime. The first DVD is more about the main character's past than about the reanimated killing machine he's become, but it definitely leaves you wanting more.",
+      "id": "61"
+    },
+    "62": {
+      "label": true,
+      "text": "Error in product description: It's great in every way. However, if you'd prefer a digital tuner (as I do), then you might need to look further. The product description boasts a digital AM/FM tuner, but it's disappointingly an analog AM/FM tuner.Overall - especially for the price - I think it's pretty good.",
+      "id": "62"
+    },
+    "63": {
+      "label": true,
+      "text": "good phone but not as user friendly as it could be: Battery life is very good. Phone has good range. My only complaint is it's to involved to get your message from the handset.",
+      "id": "63"
+    },
+    "64": {
+      "label": false,
+      "text": "Big waste of money (and space in my house!): My 5 year old son wanted this so bad, but when we got it for him, there were so many pieces to put together that didn't fit together well, he never played with it. It just sits on our floor in many pieces taking up toy space! What a waste!",
+      "id": "64"
+    },
+    "65": {
+      "label": true,
+      "text": "Don't want to take it off: Very satisfied with an earlier purchase of this Bali bra model, I was just as pleased with the new one. Very comfortable, well made and a good neutral color. It will be my next choice, too.",
+      "id": "65"
+    },
+    "66": {
+      "label": true,
+      "text": "Fantastico: If anybody who's into rock music is ever looking for a band to keep you on your toes, this is the band. I've been a fan for 10 years now, and no album has ever sounded like any of their previous albums. This disc is fantastic with such a variety of styles, as are the previous releases, even back to the Rainbow Butt Monkey days.",
+      "id": "66"
+    },
+    "67": {
+      "label": false,
+      "text": "too much visual: There are far too much designs, visuals, colors, etc in the book - this is highly distracting, as TV screen can be...By way of example (among so many...), what is the use of colors with the three squares of the Pyth. theorem???? this is as useless as writting 2+3=5 with 2 in blue, 3 in red and 5 in yellow...I wish I had purchased the 2nd edition, which according to reviews was closer to what I was looking for.",
+      "id": "67"
+    },
+    "68": {
+      "label": true,
+      "text": "Aretha's First Arista Release Showed Pleasures to Come: After a long and musically satisfying career with Atlantic, Aretha severed her ties with that company and moved under the wing of Arista's Clive Davis. With the start of the 1980's, Aretha was looking for new territory to conquer and almost succeeded with this mixed bag.\"United Together\" is a fine tune that benefits from beautiful orchestral arrangement that is matched by Aretha's superb vocal instrument. The remake of \"Can't Turn You Loose\" allows Aretha to show why she is the Queen of Soul\" for she really belts this one out. Another cover, that of the Doobies' \"What a Fool Believes,\" is an interesting interpretation. The final cut \"School Days\" appears to be \"autobiographical\" for every girl growing up in the fifties.Although not as strong as her Atlantic work, \"Aretha\" is still a suitable addition to the artist's discography.",
+      "id": "68"
+    },
+    "69": {
+      "label": false,
+      "text": "Misguided Purchase: The photo and description do not reflect the product. The screen panel kit I received was white. What a huge inconvenience during a time-crunch.",
+      "id": "69"
+    },
+    "70": {
+      "label": false,
+      "text": "Banacek: My husband and were looking forward to seeing this series.The first show was SO boring, we finally just quit watching it.Actually, we haven't gotten around to watching anymore. I guess we were afraid of a repeat.Maybe that was just once, I hope!",
+      "id": "70"
+    },
+    "71": {
+      "label": true,
+      "text": "JDT: Uncle Tupelo is without doubt one of the most under appreciated groups of the 90's. Anodyne, like each of the three albums that came before it, has everything that a remarkable recording requires: great songs, honest lyrics, and artists who really care about the music they are making. Like the best of Dylan and Springsteen, the songs are about real people with real troubles and joys. When you hear them you know they are coming from the heart. The songs contributed by Jay Farrar and Jeff Tweedy are easily differentiated by the voacls, music, and lyrics. What makes this record interesting is how well these unique sounds compliment each other. The union is seamless.",
+      "id": "71"
+    },
+    "72": {
+      "label": true,
+      "text": "Well Worth Reading: First a confession: Miriam Wasserman was my mother. However, she published several books, but this is the only one I really found useful. She walks the reader through the New York City school system and the attitudes of different groups involved in the system back in the 1960s. This includes parents, teachers and administrators. Her view is that the further away one got from parents and students, the more prestige one had. She meticulously describes the teachers' strike of 1968 against \"community control of schools\", a strike of which she is extremely critical. She explores the racism that was involved in this strike, including using quotes from striking teachers, etc. It should be emphasized that the author was pro-union all her life, so her views don't stem from an anti-union bias. The book also covers the high school student rebellion which coincided with and followed the strike.",
+      "id": "72"
+    },
+    "73": {
+      "label": true,
+      "text": "compact and loaded: I bought this phone after reading the cnet reviews and really liked it. It looks small and really compact. I like the camera pics at 2 mega pixel and bright flash. The mp3 player is crisp. The headset that comes along delvers amazing fM radio. I think my phone is not very loud and you have a problem when you are around a noisy crowd. I just bought this phone again for my cousin. He likes it too. Almost forgot the display is very good.",
+      "id": "73"
+    },
+    "74": {
+      "label": true,
+      "text": "Outstanding text!: Brooks/Cole should keep this text in their catalog for ages! It is well-written, examples are generally quite clear, vocabulary is introduced well, and the exercises develop real skills, rather than simply be busy-work. One of the best calculus books ever!",
+      "id": "74"
+    },
+    "75": {
+      "label": true,
+      "text": "Excel 2003 Bible: Very good source of information. I will most likely buy other books in this series.",
+      "id": "75"
+    },
+    "76": {
+      "label": true,
+      "text": "Tasting is Believing: Gluten-free breads used to have a gritty texture from the rice flour, and were too soft for sandwiches. Bette Hagman uses garbanzo/fava bean flour, sorghum flour, tapioca flour, and corn starch to create breads which have a similar texture to wheat flour breads, and the flavors of her breads are fabulous.My BF bought me this book and a great tasting beverage to drink it with. Since he knows I quit coffee recently, he's been really wonderful helping me in cope with my mood swings. S o y f e e is made from soy beans that is roasted just like coffee. I enjoy the taste and don't miss coffee one bit. Buy it online at www.s o y c o f fee.com.This is a 'must have' for anyone baking gluten-free. I think all of Bette Hagman's books are wonderful and a must for those with gluten intolerance.",
+      "id": "76"
+    },
+    "77": {
+      "label": true,
+      "text": "5 stars for the show, no stars for the \"Collector's Edition\": I was really looking forward to getting this Collector's Edition and see what extras were added. I knew it wasn't a lot - just a mini-book and a documentary - but I figured it would be packaged in a cool way.Wrong.As others have already mentioned, the Collector's Edition is *literally* theAvatar: The Last Airbender - The Complete Book 1 Collectionslipped into another cardboard box, with a little booklet and DVD in an envelope (not even a case!) wedged in. It's really disappointing; it would have been so easy to create a quality Collector's Edition but the studio couldn't be bothered, I guess.",
+      "id": "77"
+    },
+    "78": {
+      "label": true,
+      "text": "sula scottcampos: Sula, a book that talks about the issues of being a black women is a really good novel to read.One of the reasons I recommend it is because of its realism and its themes - death, sex, friendship and poverty.I also think that its characters are very good, its easy to identify with one or both of them. I really recommend this book to anyone who enjoys good literature.",
+      "id": "78"
+    },
+    "79": {
+      "label": true,
+      "text": "Fantastic! It's a must-have for girls!: I hated razor, tried shaving but it did not work for me. Shaving made the hair grows thicker and faster afterwards, plus the roots are impossible to be getting rid of. After reading the reviews, I ordered it to try, I used it for once and already fall in love with this. I used to use small tweezer to pluck out my leg's hair, in order to avoid the razor, it took me a few hours to do that but this super electronic tweezer works wonder! You won't see the black roots and I have smooth and silkly legs in 20 mins. It does not hurt at all, if you use it on your legs. But, if you use it at your under arm, it won't be a pleasant feeling, of course! I will never use anything else besides this for hair removing anymore! highly recommended!",
+      "id": "79"
+    },
+    "80": {
+      "label": false,
+      "text": "This is not a toy: I guess I was expecting more out of these leave window decals. I just didn't find them attractive after placing them on my window, they seem very cheap, I guess because they are cheap.I threw them away.",
+      "id": "80"
+    },
+    "81": {
+      "label": true,
+      "text": "Wonderful book for anyone running a professional hatchery: This book is aimed more for hatcheries that are raising Trout, Salmon, Catfish and other food fishes. However, there is so much information in this book that even ornamental fish hatcheries will find an incredible amount of useful information. The chapters on Fish Nutrition are especially helpful.",
+      "id": "81"
+    },
+    "82": {
+      "label": true,
+      "text": "Amazing book!!: Once again, Eric Victorino's artistic talent is put into this great free-verse poetry book. I couldn't put it down and I finished it the day I received it in the mail. All of the poems are awesome but the one I found the most interesting was \"It's A People Business.\" All of the experiences in his life, personally and with his band, come to life in this book. Please check it out! It's worth every penny!!",
+      "id": "82"
+    },
+    "83": {
+      "label": true,
+      "text": "The white trumpet contender respect Miles Davis!: The story of the Jazz in the Fifties certainly would be remain unfinished without the ominous presence of this outstanding virtuoso. Baker sound still possesses this alluring hook, this magnetic engagement charm, eloquent expressiveness, enrapturing lyricism and contagious rhythm, despite the elapsed time, which confirms by itself the status of his musicianship.This selection is jus a little sample of the broad universe of his genius. A well thought selection of great musical successes, available, preserved and immortalized by the Digital Technology for our future enjoyment.Absolutely indispensable in your treasured collection.",
+      "id": "83"
+    },
+    "84": {
+      "label": false,
+      "text": "What the?: I'm sorry, maybe it's just me but I can't helping stating that this has to be one of the wrost movies I've seen in my life!Can you say boring? Can you say doesn't make sense at all? The first 30 minutes of the movie were O.K. But it went downhill after that. This movie is a prime example of a director attempting to make a deep movie with a meaningful lesson but failed on all levels. I don't recommend this movie unless you want to go to sleep or you don't have anything else to do.",
+      "id": "84"
+    },
+    "85": {
+      "label": true,
+      "text": "very very good!!!!: linda blair is a young girl who is possessed. and her mother doesn't know what to do until one day when she hears her daughter screaming and stabbind herself she knows what to do GET AN EXORCIZIM!!!",
+      "id": "85"
+    },
+    "86": {
+      "label": true,
+      "text": "Awesome product for the price!: This range extender works as advertised! I am very happy with the purchase. I was a little worried after reading some of the horror stories here, but I have to say, Chovy's review instructions (on this site) were just this ticket to get the repeater up and running in less than 30 minutes. It was unbelievably easy to install! Do not be frightened by negative reviews. If you can set up a wireless network, you can set up this repeater. However, I did upgrade the firmware before I did anything else and maybe that helped. I got the firmware update from the Belkin site.",
+      "id": "86"
+    },
+    "87": {
+      "label": false,
+      "text": "Slight: This book is either a heavily illustrated short story collection or a text-heavy comic. Its unusual format is its most original feature. Its plots are negligible, but its illustrations and text evoke a unique atmosphere of self-conscious nonconformism. Although its target audience is dare-to-be-different teens and college students, its interesting turns of phrase and expressive line drawings are not devoid of interest for general audences.",
+      "id": "87"
+    },
+    "88": {
+      "label": true,
+      "text": "ANgeleyes: Seem to dry up their eyes fairly well, although I haven't seen the color (brown stain) change much yet.",
+      "id": "88"
+    },
+    "89": {
+      "label": false,
+      "text": "Nice Try: Salt Lake 2002 is not a bad game, but it isn't good either. The graphics are excellent, but some of the events are bad. Bobsleigh, and skiing aren't bad but the others are. You dont stay into it for long. I liked it for a while, but it gets boring.",
+      "id": "89"
+    },
+    "90": {
+      "label": false,
+      "text": "Cutler's share of the pie: This book was a major disappointment. I am familiar with books written solely by the Dalai Lama, such as the \"Library of Tibet\" series, which are much more engrossing and have much more substance than Cutler's book. Cutler attempts (successfully, sadly) to have his share of the profitable market that involves the Dalai Lama's writings. The book is insipid, does not try to explain any important issue in the light of Buddhist philosophy, and only rehashes issues that several other westerners already wrote about. It's another big ego trip: we keep hearing time and again about his opportunities to be with the Dalai Lama. What a shame, Cutler. I sold the book as soon as I finished it.",
+      "id": "90"
+    },
+    "91": {
+      "label": false,
+      "text": "Mostly tedious, with interesting parts: I found the writing interesting, and the subject fascinating, but I found myself frustrated by the author's difficulty in talking directly about the status of Muslim women with her interview subjects. The author spent many pages writing about the menus and dress of the many middle and upper-middle class women she interviewed. It seemed as though her interview subjects resisted her efforts to discuss the status of women in their countries, so we too as readers had to wade through much distracting material and misunderstandings about feminism and gender. Great travel stories, but not a great source of information about Muslim women.",
+      "id": "91"
+    },
+    "92": {
+      "label": false,
+      "text": "Sesame Street Toddler: I did not find this game to be as educationally sound as I would expect from Sesame street. There is too much talking before the program will react to a command. The graphics are jerky and the cursor acts like the target is magnetically charged and keeps pushing away the cursor. When the child actually does manage to click on a target, the cursor may still fly to another target and the child is told that his answer is wrong. Another example of educational problems is the pronunciation of \"eggs\" using a long \"a\" sound instead of a short \"e.\" This is not very helpful in teaching a child the sound for short \"e.\" Children that are used to playing computer games by themselves may find that this game is too frustrating to do alone. The open ended learning curve is a great idea. I just wish Sesame Street would hire a truly qualified literacy expert to help clean up the many problems in this program.",
+      "id": "92"
+    },
+    "93": {
+      "label": false,
+      "text": "needs a buzz cut and a point: I avoided reading this book, not because of the hermaphrodite subject matter, but because I have never read a multigenerational family saga that I liked. Many books let me down in the middle, and this was no exception. The beginning of the book was incredible and harrowing, with momentum and characterization. The post-America nextgens part of the saga was so boring I found myself flipping and flipping - always a bad sign. If there was some kind of larger point to all of that, then I must have missed it. Yes there's the identity duality and trinity themes playing out here: man/woman, greek/turkish/american modern/old world sick/healthy innocent/guilty original/reinvented. But it was almost as if the author was saying - here it is again - get it? I like my fiction much more subtle than this.",
+      "id": "93"
+    },
+    "94": {
+      "label": false,
+      "text": "OMG! DO NOT BUY!: I normally don't take the time to submit a review.In this case however, I feel obligated to do so.This is by far one of the worst purchases I have ever made.Here's why.....The contraption is far too bulky.The case's enclosing is unbearable, takes a good minute or so to open it.The texture of the material feels like a cheap toy.The overall design is horrible, something I could make in my basement.For the love of everything sacred, do not buy this thing.",
+      "id": "94"
+    },
+    "95": {
+      "label": true,
+      "text": "Good price, good quality: Comparable HDMI cables can be bought for 45 or more. Even though the price is cheap the quality is good, no problems so far.",
+      "id": "95"
+    },
+    "96": {
+      "label": true,
+      "text": "Good rock music: This is what i call rock music good beat and good lyrics, don't listen to the other reviews. This cd is one of the best, listen to a few songs and you will get hooked. I recommend this cd its awesome.",
+      "id": "96"
+    },
+    "97": {
+      "label": false,
+      "text": "BORING!: This movie is soo boring. How in the hell did this movie make so much at the box office. Do people really want to pay for crappy movies like this. bottom line this is a chick flick nothing is good. And now they are re-releasing this movie with more boring stuff. This is the worst movie ever.",
+      "id": "97"
+    },
+    "98": {
+      "label": false,
+      "text": "Already Rusting: Inferior quality. The plating is thin and rust is coming through the finish. Inexcusable for a product that is designed for use in a humid environment.",
+      "id": "98"
+    },
+    "99": {
+      "label": false,
+      "text": "confusing internet setup: i wanted a camera that could email photos but this camera will not go out through the router and the manual setup , to punch a hole thru router is confusing.",
+      "id": "99"
+    },
+    "55066581ad334ef5844c6f7707525010": {
+      "label": true,
+      "text": "Thought this was super cool, and a really important step in all the physical books' preservation.",
+      "id": "55066581ad334ef5844c6f7707525010"
+    },
+    "fef14d13366f482d9f4e0726b357f178": {
+      "label": true,
+      "text": "There are some amazing hikes around Mt. Fuji.",
+      "id": "fef14d13366f482d9f4e0726b357f178"
+    },
+    "70aed7369aa74031a06f5f3155476d7c": {
+      "label": true,
+      "text": "Thought this was super cool, and a really important step in preserving all the physical books.",
+      "id": "70aed7369aa74031a06f5f3155476d7c"
+    },
+    "ac65d14b710648b8bf3c2a53caf6ac91": {
+      "label": false,
+      "text": "The profits of the business that was most successful were still negative.",
+      "id": "ac65d14b710648b8bf3c2a53caf6ac91"
+    },
+    "ce00e6b1547444259a13c55654e66500": {
+      "label": true,
+      "text": "love them best, they reconnect in hysterically funny and emotionally significant ways.",
+      "id": "ce00e6b1547444259a13c55654e66500"
+    },
+    "8943a94d205b43ceb4420d5ab9c5611a": {
+      "label": true,
+      "text": "Walt Disney's timeless masterpiece is an extravaganza of sight and sound! See the music come to life, hear the pictures burst into song and experience the excitement that is Fantasia over and over again.",
+      "id": "8943a94d205b43ceb4420d5ab9c5611a"
+    },
+    "6af8fc3dd30d4f8caf5a2929fc88534b": {
+      "label": false,
+      "text": "A director struggles with a difficult sex scene between a young actor and actress who can't stand one another. Aided by her loyal assistant, she is hell-bent on getting the scene right without compromise.",
+      "id": "6af8fc3dd30d4f8caf5a2929fc88534b"
+    },
+    "dbe571ed810d40f48170147dcab1c90f": {
+      "label": false,
+      "text": "sound created by drawing directly on the soundtrack).",
+      "id": "dbe571ed810d40f48170147dcab1c90f"
+    },
+    "682102dfc5494f03926d16ae947a6250": {
+      "label": true,
+      "text": "one of glowing admiration! Written by Mark Toscano",
+      "id": "682102dfc5494f03926d16ae947a6250"
+    },
+    "9b044458bb0e4bd68359e62d5fb4b979": {
+      "label": false,
+      "text": "Seth McArdle (Samuel Davis) is a high school senior with an especially full plate. Not only must he navigate the usual social and academic pitfalls of high school, but he has to contend with his young twin sisters, serving as de facto parent in the absence of his deceased mother and deadbeat father. The pressure mounts when the bank calls with a foreclosure warning, and Seth's frustrations spill",
+      "id": "9b044458bb0e4bd68359e62d5fb4b979"
+    },
+    "abf2d24c7d8845769b7368be28f2c25d": {
+      "label": true,
+      "text": "Bjork is a beautiful creature and her music is stellar to anything I've ever heard. This DVD is essential for all Bjork fans, because you find something new every time you watch it.",
+      "id": "abf2d24c7d8845769b7368be28f2c25d"
+    }
+  },
+  "version": 11,
+  "description": "Positive sentiment"
+}

lilac/concepts/source-code/concept.json

@@ -0,0 +1,389 @@
+{
+  "namespace": "lilac",
+  "concept_name": "source-code",
+  "type": "text",
+  "data": {
+    "c7d0400c6e5442a59859ea7b0a7d6bab": {
+      "label": true,
+      "text": "const num1 = 10;\nconst num2 = 20;\nconst sum = num1 + num2;",
+      "id": "c7d0400c6e5442a59859ea7b0a7d6bab"
+    },
+    "cfa936b9ba9e4c72b835b44d8cfb393b": {
+      "label": true,
+      "text": "function calculateArea(radius) {\n  return Math.PI * radius * radius;\n}",
+      "id": "cfa936b9ba9e4c72b835b44d8cfb393b"
+    },
+    "3952102e61a44fde92117a0519c4e8e6": {
+      "label": true,
+      "text": "let message = 'Hello, World!';\nconsole.log(message);",
+      "id": "3952102e61a44fde92117a0519c4e8e6"
+    },
+    "6e90cb4c8fdb46a1b38460b5d2eca907": {
+      "label": true,
+      "text": "for (let i = 0; i < 10; i++) {\n  console.log(i);\n}",
+      "id": "6e90cb4c8fdb46a1b38460b5d2eca907"
+    },
+    "7e7a438002384ae194f35f27b9c85888": {
+      "label": true,
+      "text": "const colors = ['red', 'green', 'blue'];\nfor (const color of colors) {\n  console.log(color);\n}",
+      "id": "7e7a438002384ae194f35f27b9c85888"
+    },
+    "91cc90d155ef4c1fb4f3c458cfdc8fac": {
+      "label": false,
+      "text": "No bathroom bill made it to Abbott\u2019s desk by the end of the legislative session in May.",
+      "id": "91cc90d155ef4c1fb4f3c458cfdc8fac"
+    },
+    "c67e408ec3544898a0d3fc21c2ee36c3": {
+      "label": false,
+      "text": "The theory that they are products of the radiation from the bomb is genius.",
+      "id": "c67e408ec3544898a0d3fc21c2ee36c3"
+    },
+    "fa78b497c7704c198fe0b2a320ed55e6": {
+      "label": false,
+      "text": "We built our society on clean energy.",
+      "id": "fa78b497c7704c198fe0b2a320ed55e6"
+    },
+    "a8bef6215f2346f7b67101b055724e99": {
+      "label": false,
+      "text": "No bathroom bill made it to Abbott\u2019s desk by the end of the legislative session in May.",
+      "id": "a8bef6215f2346f7b67101b055724e99"
+    },
+    "cab51176c2f74c8497410764628ea7cf": {
+      "label": false,
+      "text": "They should be attached to the lifting mechanism in the faucet.",
+      "id": "cab51176c2f74c8497410764628ea7cf"
+    },
+    "6585fbabe83444cfb43dee977dc3ebfe": {
+      "label": false,
+      "text": "This dataset is very big.",
+      "id": "6585fbabe83444cfb43dee977dc3ebfe"
+    },
+    "59e8b12ef7dd4e948dfae42c97f55721": {
+      "label": false,
+      "text": "The 15th Tank Corps was a corps of the Soviet Union's Red Army.",
+      "id": "59e8b12ef7dd4e948dfae42c97f55721"
+    },
+    "efaa58793e2840c6b966caa6a11ecaad": {
+      "label": false,
+      "text": "Every lunch hour I make it my goal to sift through one research paper.",
+      "id": "efaa58793e2840c6b966caa6a11ecaad"
+    },
+    "b529748962774d36a4ff781da0e327bf": {
+      "label": false,
+      "text": "On Sunday, Jane had a party.",
+      "id": "b529748962774d36a4ff781da0e327bf"
+    },
+    "b6f2f93f75f44d3780882cd1ebd3d311": {
+      "label": false,
+      "text": "TIL David Attenborough and Queen Elizabeth II are roughly the same age.",
+      "id": "b6f2f93f75f44d3780882cd1ebd3d311"
+    },
+    "2c04925ab5114925b9e891eb2706b83e": {
+      "label": true,
+      "text": "```js\nfor (var i = 1; i < 12; i++) {\n   console.log(i);\n}\n```",
+      "id": "2c04925ab5114925b9e891eb2706b83e"
+    },
+    "030117a7d9044dd8b055c80853804d3d": {
+      "label": false,
+      "text": "\u00a1Desde luego! Aqu\u00ed tienes unas secuencias del tipo \"123456789\" convertidas en operaciones aritm\u00e9ticas (haciendo uso de los operadores + y -) cuyo resultado da 200:\n\n* 123 + 4 + 5 + 67 - 8 + 9 = 200\n* 123 - 4 + 5 - 6 - 7 + 89 = 200\n* 1 + 234 - 5 - 6 - 7 - 8 - 9 = 200",
+      "id": "030117a7d9044dd8b055c80853804d3d"
+    },
+    "c0095d13aed4431bb75bbc215b0d4819": {
+      "label": false,
+      "text": "and the Roman Senate was often more interested in maintaining their own power and wealth than in governing effectively.",
+      "id": "c0095d13aed4431bb75bbc215b0d4819"
+    },
+    "6ea50e4168ed42fe94ce15a9c330a54f": {
+      "label": true,
+      "text": "```javascript\n// Get the canvas element\nconst canvas = document.getElementById('myCanvas');\n\n// Get the 2D context of the canvas\nconst ctx = canvas.getContext('2d');\n\n// Set the position of the circle\nconst x = 100; // X coordinate\nconst y = 100; // Y coordinate\n\n// Set the radius of the circle\nconst radius = 50;\n\n// Set the color of the circle\nconst color = 'blue';",
+      "id": "6ea50e4168ed42fe94ce15a9c330a54f"
+    },
+    "7266060a88d04a6299922714f62091d8": {
+      "label": false,
+      "text": "Certainly! Here's a simple JavaScript function that takes a mathematical expression as a string and a value for x, then returns the result of the operation:\n\n",
+      "id": "7266060a88d04a6299922714f62091d8"
+    },
+    "6bf7df5363ff4eb3ac237eed4acda0af": {
+      "label": false,
+      "text": "Another factor in Rome's decline was the empire's overextended infrastructure. The Roman Empire was renowned for its impressive network of roads, aqueducts, and other public works. However, as the empire expanded and resources became scarce, the maintenance of these critical systems was neglected. This deterioration led to problems such as a lack of clean drinking water, food shortages, and the",
+      "id": "6bf7df5363ff4eb3ac237eed4acda0af"
+    },
+    "048952d5e620410282e09d625dc45f20": {
+      "label": true,
+      "text": "```javascript\nconst canvas = document.getElementById('canvas'); // note that you will have to use your own canvas\nconst context = canvas.getContext('2d');\nconst x = 100; // x-coordinate, you can set it up\nconst y = 100; // y-coordinate, you can set it up too\nconst radius = 50; // radius of the circle, set-up-able\nconst color = 'red'; // color of the circle, also set-up-able\ncontext.beginPath();",
+      "id": "048952d5e620410282e09d625dc45f20"
+    },
+    "eb5ee4b631bc400d95aa21aed4cb1dcd": {
+      "label": true,
+      "text": "```javascript\n// Get the canvas element from the DOM\nconst canvas = document.getElementById('canvas');\n\n// Get the 2D context of the canvas\nconst ctx = canvas.getContext('2d');\n\n// Set the position, radius, and color of the circle\nconst x = 50;\nconst y = 50;\nconst radius = 30;\nconst color = 'red';\n\n// Begin a new path\nctx.beginPath();\n\n// Draw the circle\nctx.arc(x, y, radius, 0, 2 * Math.PI);",
+      "id": "eb5ee4b631bc400d95aa21aed4cb1dcd"
+    },
+    "ca0e90e7a6f54427997b9c98ab86508e": {
+      "label": true,
+      "text": "  const getColor = (depth) => {\n    if (depth < 0.25) {\n      return `rgb(0, ${Math.floor(depth * 1020)}, 255)`;\n    } else if (depth < 0.5) {\n      return `rgb(0, 255, ${Math.floor(1020 - depth * 1020)})`;\n    } else if (depth < 0.75) {\n      return `rgb(${Math.floor(depth * 1020) - 255}, 255, 0)`;\n    } else {\n      return `rgb(255, ${Math.floor(1020 - depth * 1020)}, 0)`;\n    }\n  };",
+      "id": "ca0e90e7a6f54427997b9c98ab86508e"
+    },
+    "bec8c965143b4a0dba7add98346996a0": {
+      "label": false,
+      "text": "Rome itself. Consequently, military leadership was fraught with intrigue, as ambitious generals vied for power, often at the expense of the empire's stability.",
+      "id": "bec8c965143b4a0dba7add98346996a0"
+    },
+    "8342a4029d384b5183a78ca0dc7e398e": {
+      "label": true,
+      "text": "\n  \n  \n  \n  \n  \n  \n  \n window._taboola = window._taboola || []; _taboola.push({ mode: 'thumbnails-c', container: 'taboola-interstitial-gallery-thumbnails-5', placement: 'Interstitial Gallery Thumbnails 5', target_type: 'mix' }); \n  \n  \n  ",
+      "id": "8342a4029d384b5183a78ca0dc7e398e"
+    },
+    "aecfb1e4c7ba45fb8847f304c5c848af": {
+      "label": false,
+      "text": "miles an hour,\" and worried that their \"uteruses would fly out of [their] bodies as they were accelerated to that speed.\" ",
+      "id": "aecfb1e4c7ba45fb8847f304c5c848af"
+    },
+    "6a6aaea62afc43258b646b4b25d93692": {
+      "label": true,
+      "text": "  \n window._taboola = window._taboola || []; _taboola.push({ mode: 'thumbnails-c', container: 'taboola-interstitial-gallery-thumbnails-15', placement: 'Interstitial Gallery Thumbnails 15', target_type: 'mix' }); _taboola.push({flush: true}); \n  ",
+      "id": "6a6aaea62afc43258b646b4b25d93692"
+    },
+    "4f94dc90c0c94420a99301ac1fc92171": {
+      "label": true,
+      "text": "  \n window._taboola = window._taboola || []; _taboola.push({ mode: 'thumbnails-c', container: 'taboola-interstitial-gallery-thumbnails-25', placement: 'Interstitial Gallery Thumbnails 25', target_type: 'mix' }); _taboola.push({flush: true}); \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  \n  ",
+      "id": "4f94dc90c0c94420a99301ac1fc92171"
+    },
+    "64e15fb5d64548ca8b0d2c288916d303": {
+      "label": false,
+      "text": "Choose the Ellipse, Rectangle, or Polygon tool from InDesign's Tools panel. Adjust your background shape's size by clicking one of your shape's handles with your Select tool and dragging it until your shape is the correct size. Make sure the object is selected, then open InDesign's Swatches panel and select the Fill button. Choose the color you want to apply from the Swatches panel. Your shape",
+      "id": "64e15fb5d64548ca8b0d2c288916d303"
+    },
+    "3374e377ae4440a98626ae06aba98dea": {
+      "label": true,
+      "text": "  \n window._taboola = window._taboola || []; _taboola.push({ mode: 'thumbnails-c', container: 'taboola-interstitial-gallery-thumbnails-20', placement: 'Interstitial Gallery Thumbnails 20', target_type: 'mix' }); _taboola.push({flush: true}); \n  ",
+      "id": "3374e377ae4440a98626ae06aba98dea"
+    },
+    "2e14c0bbc5d84955b6b65f502b599eda": {
+      "label": true,
+      "text": "value=\"#000000\" /><param name=\"allowScriptAccess\" value=\"always\" /><param name=\"allowFullScreen\" value=\"true\" /><param name=\"flashvars\" value=\"embedType=noscriptObjectTag&embedCode=1udG03NTowIl-eAG5T0wYzU_zYNmmNht&videoPcode=BhdmY6l9g002rBhQ6aEBZiheacDu\" /><embed src=\"http://player.ooyala.com/player.swf?embedCode=1udG03NTowIl-eAG5T0wYzU_zYNmmNht&version=2\" bgcolor=\"#000000\" width=\"618\"",
+      "id": "2e14c0bbc5d84955b6b65f502b599eda"
+    },
+    "a556ea1110714d38ad2fdcaac47a4332": {
+      "label": false,
+      "text": "What are the best resources to learn Express.js?\nWhat is the best way to learn AngularJS and nodeJS?\n\nAre these two questions inquiring about the same information?",
+      "id": "a556ea1110714d38ad2fdcaac47a4332"
+    },
+    "20f20d8cff8c475f93b25298e5f58ff2": {
+      "label": true,
+      "text": "  \n window._taboola = window._taboola || []; _taboola.push({ mode: 'thumbnails-c', container: 'taboola-interstitial-gallery-thumbnails-10', placement: 'Interstitial Gallery Thumbnails 10', target_type: 'mix' }); _taboola.push({flush: true}); \n  ",
+      "id": "20f20d8cff8c475f93b25298e5f58ff2"
+    },
+    "7f810a7c98bc4d44a3dd07688d39ae02": {
+      "label": false,
+      "text": "used on the left side and when used on the right side it extends too far forward. C'est la Vie. I will try it on my XBox next. Answer:",
+      "id": "7f810a7c98bc4d44a3dd07688d39ae02"
+    },
+    "3b476d5fbd0f472eb26485a58690f62a": {
+      "label": true,
+      "text": "let-Step-7Bullet1.jpg\",\"smallWidth\":460,\"smallHeight\":306,\"bigWidth\":\"728\",\"bigHeight\":\"485\",\"licensing\":\"<div",
+      "id": "3b476d5fbd0f472eb26485a58690f62a"
+    },
+    "5c51478ab56d4ef580aec02f4554a557": {
+      "label": true,
+      "text": "  \n window._taboola = window._taboola || []; _taboola.push({ mode: 'thumbnails-c', container: 'taboola-interstitial-gallery-thumbnails-5', placement: 'Interstitial Gallery Thumbnails 5', target_type: 'mix' }); _taboola.push({flush: true}); \n  ",
+      "id": "5c51478ab56d4ef580aec02f4554a557"
+    },
+    "8c1657d2e75b440aae9c0c36162f13b5": {
+      "label": false,
+      "text": "Worries increased with age. People ages 30 to 49 \u2014 a time when people are coping with tuition payments, car payments and child-care costs \u2014 were the most likely to say they are limiting their monthly spending. And seniors were three times as likely as those 18 to 29 to say stagnant income was the main reason for cutting back.",
+      "id": "8c1657d2e75b440aae9c0c36162f13b5"
+    },
+    "123e676caaba4266bc2cf174c33a9816": {
+      "label": true,
+      "text": "Aqu\u00ed hay un ejemplo de c\u00f3mo realizar una operaci\u00f3n AND en dos bytes en JavaScript:\n\nconst byte1 = 0b10101010; // 170 en decimal\nconst byte2 = 0b11110000; // 240 en decimal\n\nconst resultado = byte1 & byte2;\n\nconsole.log(resultado.toString(2)); // \"10100000\"",
+      "id": "123e676caaba4266bc2cf174c33a9816"
+    },
+    "5990d015dd1249a58af88ec3adca6a58": {
+      "label": false,
+      "text": "How in JavaScript draw a circle with radius 10 pixels in a html canvas?",
+      "id": "5990d015dd1249a58af88ec3adca6a58"
+    },
+    "ca62cf272b1e463aa973d1f23eb25fc5": {
+      "label": false,
+      "text": "such as Tacitus and Livy, and philosophers like Seneca and Marcus Aurelius influencing generations of thinkers and writers.",
+      "id": "ca62cf272b1e463aa973d1f23eb25fc5"
+    },
+    "5a7986b9233d45b1b194001c74c98af0": {
+      "label": true,
+      "text": "menu.    {\"smallUrl\":\"https:\\/\\/www.wikihow.com\\/images\\/thumb\\/a\\/ad\\/Enable-Automatic-Updates-Step-5Bullet3.jpg\\/v4-460px-Enable-Automatic-Updates-Step-5Bullet3.jpg\",\"bigUrl\":\"\\/images\\/thumb\\/a\\/ad\\/Enable-Automatic-Updates-Step-5Bullet3.jpg\\/aid1480351-v4-728px-Enable-Automatic-Updates-Step-5Bullet3.jpg\",\"smallWidth\":460,\"smallHeight\":345,\"bigWidth\":\"728\",\"bigHeight\":\"546\",\"licensing\":\"<div",
+      "id": "5a7986b9233d45b1b194001c74c98af0"
+    },
+    "3148cb870d2a40009e9d17b0c6056470": {
+      "label": true,
+      "text": "allow_photos=false, maxitems=7, display_ugc_photos=false, includepause=true, canvas_allcomments_app_instance=6634zxcgfd, includepermalink=false}!!",
+      "id": "3148cb870d2a40009e9d17b0c6056470"
+    },
+    "874e2014361046e6988229dd17674847": {
+      "label": true,
+      "text": "   {\"smallUrl\":\"https:\\/\\/www.wikihow.com\\/images\\/thumb\\/4\\/4c\\/Enable-Automatic-Updates-Step-5Bullet2.jpg\\/v4-460px-Enable-Automatic-Updates-Step-5Bullet2.jpg\",\"bigUrl\":\"\\/images\\/thumb\\/4\\/4c\\/Enable-Automatic-Updates-Step-5Bullet2.jpg\\/aid1480351-v4-728px-Enable-Automatic-Updates-Step-5Bullet2.jpg\",\"smallWidth\":460,\"smallHeight\":345,\"bigWidth\":\"728\",\"bigHeight\":\"546\",\"licensing\":\"<div",
+      "id": "874e2014361046e6988229dd17674847"
+    },
+    "9d5510fa41a24f3aa77ccb3e2f37c366": {
+      "label": true,
+      "text": "   {\"smallUrl\":\"https:\\/\\/www.wikihow.com\\/images\\/thumb\\/e\\/ee\\/Enable-Automatic-Updates-Step-5Bullet4.jpg\\/v4-460px-Enable-Automatic-Updates-Step-5Bullet4.jpg\",\"bigUrl\":\"\\/images\\/thumb\\/e\\/ee\\/Enable-Automatic-Updates-Step-5Bullet4.jpg\\/aid1480351-v4-728px-Enable-Automatic-Updates-Step-5Bullet4.jpg\",\"smallWidth\":460,\"smallHeight\":345,\"bigWidth\":\"728\",\"bigHeight\":\"546\",\"licensing\":\"<div",
+      "id": "9d5510fa41a24f3aa77ccb3e2f37c366"
+    },
+    "4bf8a3da04e040b58b2216f231b23272": {
+      "label": false,
+      "text": "want to edit the size of the original image.  Save the image as a separate copy.  Add \"thumbnail\" or something similar to the end of the copy of the image (i.e. weddingphoto_thumbnail.jpg).  Use the following steps to create a copy of the image:  Click File  Click Save As. Type a name for the image next to \"Filename\". Click Save. It's in the upper-left corner above the box labeled \"Image\". It's at",
+      "id": "4bf8a3da04e040b58b2216f231b23272"
+    },
+    "04c7fc7da2a44936accb79f9abc65a94": {
+      "label": false,
+      "text": "Two-thirds of Americans say they aren\u2019t spending as much as they could each month, according to the poll released Tuesday by Bankrate.com. And they may keep spending down even as they enter the holiday season, says Greg McBride, chief financial analyst for Bankrate.com. \u201cPeople just don\u2019t have a lot of extra money to throw around,\u201d he says.",
+      "id": "04c7fc7da2a44936accb79f9abc65a94"
+    },
+    "46f6088066c24694b5448648160540f1": {
+      "label": false,
+      "text": "Update 1 : I have discovered problems with logging in and with the display of the CAPTCHA images when using FireFox 3.0.1 browser . These are currently being investigated . Update 2 : The problems noted above seem to be fixed .\n\nGenerate a question about the above context.",
+      "id": "46f6088066c24694b5448648160540f1"
+    },
+    "1d44b65a89214a8eaaa305d18c5d13e9": {
+      "label": false,
+      "text": "One bright note: Young people are saving more. Millennials were most likely to cite the need to save as their main reason for cutting down spending. Younger consumers, who are also less likely to own a credit card, and may be overwhelmed by student loans, recognize the importance of having emergency savings. \u201cMany of them are building a solid financial foundation,\u201d McBride says.",
+      "id": "1d44b65a89214a8eaaa305d18c5d13e9"
+    },
+    "490ef080fa174d938dba33adc155fd4c": {
+      "label": true,
+      "text": "of time.    {\"smallUrl\":\"https:\\/\\/www.wikihow.com\\/images\\/thumb\\/b\\/bd\\/Enable-Automatic-Updates-Step-5Bullet1.jpg\\/v4-460px-Enable-Automatic-Updates-Step-5Bullet1.jpg\",\"bigUrl\":\"\\/images\\/thumb\\/b\\/bd\\/Enable-Automatic-Updates-Step-5Bullet1.jpg\\/aid1480351-v4-728px-Enable-Automatic-Updates-Step-5Bullet1.jpg\",\"smallWidth\":460,\"smallHeight\":345,\"bigWidth\":\"728\",\"bigHeight\":\"546\",\"licensing\":\"<div",
+      "id": "490ef080fa174d938dba33adc155fd4c"
+    },
+    "8c39537e3827468fa16039966fbb2fec": {
+      "label": true,
+      "text": "VALUE=\"0\"><PARAM NAME=\"DisplayForeColor\" VALUE=\"16777215\"><PARAM NAME=\"DisplayMode\" VALUE=\"0\"><PARAM NAME=\"DisplaySize\" VALUE=\"4\"><PARAM NAME=\"Enabled\" VALUE=\"-1\"><PARAM NAME=\"EnableContextMenu\" VALUE=\"-1\"><PARAM NAME=\"EnablePositionControls\" VALUE=\"-1\"><PARAM NAME=\"EnableFullScreenControls\" VA!",
+      "id": "8c39537e3827468fa16039966fbb2fec"
+    },
+    "23bdbe40c81e45b487d653f936459bdf": {
+      "label": true,
+      "text": "<font class=\"smalltext\" color=\"#999966\">11/7 -- HOT JOBS </font><br />\n<font class=\"itext\"> <A HREF=\"http://www.businessweek.com/careers/content/nov2001/ca2001117_9208.htm?c=bwinsidernov09&n=link45&t=email\">\n<B>A Surge of Civic-Mindedness</B></a></font> <br />\n<font class=\"itext\">September 11 and a bad economy have folks flocking to find work in the government ",
+      "id": "23bdbe40c81e45b487d653f936459bdf"
+    },
+    "a2d7ac3aa9054cc193afb92aaaf2db10": {
+      "label": true,
+      "text": "howGotoBar\" VALUE=\"0\"><PARAM NAME=\"ShowPositionControls\" VALUE=\"-1\"><PARAM NAME=\"ShowStatusBar\" VALUE=\"0\"><PARAM NAME=\"ShowTracker\" VALUE=\"-1\"><PARAM NAME=\"TransparentAtStart\" VALUE=\"0\"><PARAM NAME=\"VideoBorderWidth\" VALUE=\"0\"><PARAM NAME=\"VideoBorderColor\" VALUE=\"0\"><PARAM NAME=\"VideoBorder3D\" VALUE=\"0\"><PARAM NAME=\"Volume\" VALUE=\"-260\"><PARAM NAME=\"WindowlessVideo\" VALUE=\"0\">",
+      "id": "a2d7ac3aa9054cc193afb92aaaf2db10"
+    },
+    "064bcd09ae674b3a93a8a28b2f2d776a": {
+      "label": true,
+      "text": "NAME=\"SendMouseClickEvents\" VALUE=\"0\"><PARAM NAME=\"SendMouseMoveEvents\" VALUE=\"0\"><PARAM NAME=\"SendPlayStateChangeEvents\" VALUE=\"-1\"><PARAM NAME=\"ShowCaptioning\" VALUE=\"0\"><PARAM NAME=\"ShowControls\" VALUE=\"0\"><PARAM NAME=\"ShowAudioControls\" VALUE=\"-1\"><PARAM NAME=\"ShowDisplay\" VALUE=\"0\"><PARAM NAME=\"S!",
+      "id": "064bcd09ae674b3a93a8a28b2f2d776a"
+    },
+    "3964174632e949bba35991a1ad18cd66": {
+      "label": false,
+      "text": "1) Through Terminal Server (the one that opens up a desktop within a desktop and it actually appears that you have two Start buttons). \nor\n2) By opening the Stack Manager directly from your \"native\" desktop.\n\nPlease reply to this message with either a corresponding \"1\" or a \"2\" in the subject field.",
+      "id": "3964174632e949bba35991a1ad18cd66"
+    },
+    "f79e3b6f46444f05ac04fc2661f2fc23": {
+      "label": true,
+      "text": "```\nimport React, { useState } from \"react\";\n\nfunction Ball() {\n  const [position, setPosition] = useState({ x: 0, y: 0 });\n\n  const handleMouseMove = (event) => {\n    setPosition({ x: event.clientX, y: event.clientY });\n  };",
+      "id": "f79e3b6f46444f05ac04fc2661f2fc23"
+    },
+    "2e71a1fa193a42e0b04c399666939997": {
+      "label": true,
+      "text": "7. Por \u00faltimo, itera a trav\u00e9s de los resultados de b\u00fasqueda y muestra el nombre del canal y una miniatura para cada uno:\n\nreturn (\n  <div>\n    <form>\n      <input type=\"text\" value={query} onChange={handleInputChange} />\n      <button type=\"button\" onClick={searchTwitch}>Search</button>\n    </form>",
+      "id": "2e71a1fa193a42e0b04c399666939997"
+    },
+    "3c5fdf9f6a194342a83f59127257ad56": {
+      "label": false,
+      "text": "the Eastern Roman Empire, or the Byzantine Empire, would continue to survive and even flourish for many centuries, the fall of the Western Roman Empire in 476 CE marked a dramatic turning point in world history. The legacy of the Roman Empire endures in the many aspects of modern society that have been influenced by its achievements, from language and law to art and architecture. The Latin",
+      "id": "3c5fdf9f6a194342a83f59127257ad56"
+    },
+    "60a6019fa6da495aa395d80568867fdd": {
+      "label": true,
+      "text": "import React, { useState } from \"react\";\n\nfunction BallFollowingMouse() {\n  const [position, setPosition] = useState({ x: 0, y: 0 });\n\n  function handleMouseMove(event) {\n    setPosition({ x: event.clientX, y: event.clientY });\n  }",
+      "id": "60a6019fa6da495aa395d80568867fdd"
+    },
+    "24a37a8d1bde4548807c27fa75a611c2": {
+      "label": true,
+      "text": "```js\nwhile (condicion) {\n  // sentencia(s);\n}\n```",
+      "id": "24a37a8d1bde4548807c27fa75a611c2"
+    },
+    "dd489a1ec0d0444f894c57d2f0f30fc1": {
+      "label": true,
+      "text": "```\nconst btn = document.getElementById(\"showFormBtn\");\nconst form = document.getElementById(\"form\");\n\nbtn.addEventListener(\"click\", function() {\n  if (form.style.display === \"block\") {\n    form.style.display = \"none\";\n  } else {\n    form.style.display = \"block\";\n    form.elements[0].focus();\n  }\n});\n```",
+      "id": "dd489a1ec0d0444f894c57d2f0f30fc1"
+    },
+    "1fd93665d3ea44fca509521c179ac54b": {
+      "label": false,
+      "text": "\u041f\u043e\u0441\u043b\u0435 \u0443\u0441\u0442\u0430\u043d\u043e\u0432\u043a\u0438 \u0431\u0438\u0431\u043b\u0438\u043e\u0442\u0435\u043a\u0438 \u0432\u044b \u043c\u043e\u0436\u0435\u0442\u0435 \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u044c \u0435\u0435 \u0432 \u0441\u0432\u043e\u0435\u043c \u043f\u0440\u043e\u0435\u043a\u0442\u0435. \u0411\u0438\u0431\u043b\u0438\u043e\u0442\u0435\u043a\u0430 FFT.js \u043f\u0440\u0435\u0434\u043b\u0430\u0433\u0430\u0435\u0442 \u043d\u0430\u0431\u043e\u0440 \u0444\u0443\u043d\u043a\u0446\u0438\u0439, \u043a\u043e\u0442\u043e\u0440\u044b\u0435 \u043c\u043e\u0436\u043d\u043e \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u044c \u0434\u043b\u044f \u0432\u044b\u043f\u043e\u043b\u043d\u0435\u043d\u0438\u044f \u0424\u0443\u0440\u044c\u0435-\u0430\u043d\u0430\u043b\u0438\u0437\u0430 \u043d\u0430 \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u0435\u043d\u043d\u043e\u043c \u043d\u0430\u0431\u043e\u0440\u0435 \u0434\u0430\u043d\u043d\u044b\u0445. \u0424\u0443\u043d\u043a\u0446\u0438\u0438 fft \u0438 ifft - \u044d\u0442\u043e \u0434\u0432\u0435 \u043a\u043b\u044e\u0447\u0435\u0432\u044b\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u0438, \u043a\u043e\u0442\u043e\u0440\u044b\u0435 \u0432\u0430\u043c \u043d\u0443\u0436\u043d\u043e \u0431\u0443\u0434\u0435\u0442 \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u044c. \u041d\u0430 \u0432\u0445\u043e\u0434 \u0444\u0443\u043d\u043a\u0446\u0438\u0438 fft \u043f\u0435\u0440\u0435\u0434\u0430\u0435\u0442\u0441\u044f \u043c\u0430\u0441\u0441\u0438\u0432 \u043a\u043e\u043c\u043f\u043b\u0435\u043a\u0441\u043d\u044b\u0445 \u0447\u0438\u0441\u0435\u043b, \u0438 \u043e\u043d\u0430 \u0432\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u043c\u0430\u0441\u0441\u0438\u0432 \u043a\u043e\u043c\u043f\u043b\u0435\u043a\u0441\u043d\u044b\u0445 \u0447\u0438\u0441\u0435\u043b, \u043a\u043e\u0442\u043e\u0440\u044b\u0439",
+      "id": "1fd93665d3ea44fca509521c179ac54b"
+    },
+    "0362a26ed9024f6d9fb39dfa39e113b0": {
+      "label": true,
+      "text": "const calculadora=document.getElementById('calculadora')const resultado=document.getElementById('resultado') calculadora.addEventListener('click',a\u00f1adirNumeros) let operaciones=[] function",
+      "id": "0362a26ed9024f6d9fb39dfa39e113b0"
+    },
+    "20d9a45df83e4ad1a092ea00e4d2204a": {
+      "label": true,
+      "text": ".calculator-keys button[value=\"calculate\"] {\n  grid-column: 3/5;\n}\nAgregue la funcionalidad de la calculadora utilizando JavaScript. Debe agregar un controlador de eventos para cada bot\u00f3n de la calculadora y escribir la l\u00f3gica para realizar los c\u00e1lculos. Por ejemplo:\nvbnet",
+      "id": "20d9a45df83e4ad1a092ea00e4d2204a"
+    },
+    "dff7dec5c01d4fc185f633dbe3c32b60": {
+      "label": true,
+      "text": "const calculator = document.querySelector('.calculator');\nconst keys = calculator.querySelector('.calculator-keys');\nconst screen = calculator.querySelector('.calculator-screen');\n\nkeys.addEventListener('click', event => {\n  if (!event.target.matches('button')) {\n    return;\n  }\n\n  const key = event.target;\n  const keyValue = key.value;\n  const displayValue = screen.textContent;",
+      "id": "dff7dec5c01d4fc185f633dbe3c32b60"
+    },
+    "53d4066c6d704bd79f2d531a1f9562f4": {
+      "label": true,
+      "text": "\n    if (!phoneRegex.test(phoneValue)) {return inputError(\"phone\")}\n\n    if (passwordValue !== passwordConfirmValue) {\n        inputError(\"password\");\n        return inputError(\"confirm-password\");\n    }\n\n\n});\n\nfunction inputError(inputName) {\n    form.elements[inputName].style.border = \"1px solid red\";\n}\n```",
+      "id": "53d4066c6d704bd79f2d531a1f9562f4"
+    },
+    "59f75053fff04c879d1aacfb7bd8b51b": {
+      "label": true,
+      "text": "const App = () => {\n  const [elements1, setElements1] = useState([\n    { id: 1, text: 'Element 1' },\n    { id: 2, text: 'Element 2' },\n    { id: 3, text: 'Element 3' },\n  ]);\n  const [elements2, setElements2] = useState([\n    { id: 4, text: 'Element 4' },\n    { id: 5, text: 'Element 5' },\n    { id: 6, text: 'Element 6' },\n  ]);",
+      "id": "59f75053fff04c879d1aacfb7bd8b51b"
+    },
+    "cda55f47106b4a40b49bf9b8722cd7f1": {
+      "label": true,
+      "text": "```js\nfetch(\"/robots.txt\")\n  .then(response => {\n    return response.text(); // Devuelve una promesa\n  })\n  .then(data => {\n    console.log(data);\n  })\n  .catch(error => { /* C\u00f3digo a realizar cuando se rechaza la promesa */ });\n```",
+      "id": "cda55f47106b4a40b49bf9b8722cd7f1"
+    },
+    "397f7180a5af495a874646051f8bc248": {
+      "label": true,
+      "text": "  const handleButtonClick = async () => {\n    try {\n      const response = await axios.get(`https://example-api.com/${inputValue}`);\n      setResult(response.data);\n    } catch (error) {\n      console.error(error);\n    }\n  };",
+      "id": "397f7180a5af495a874646051f8bc248"
+    },
+    "4439280d86e644da8c5a10277ba7777a": {
+      "label": true,
+      "text": "                client.send(message);\n            }\n    });\n});\n```",
+      "id": "4439280d86e644da8c5a10277ba7777a"
+    },
+    "e54d850ca2cb41c5a869936baad2163f": {
+      "label": true,
+      "text": "```javascript\nconst axios = require('axios');\nconst cheerio = require('cheerio');\n\nconst getData = async () => {\n  const response = await axios.get('https://www.realestate.com.au/rent/in-sydney,+nsw/list-1');\n  const $ = cheerio.load(response.data);\n  \n  const properties = [];\n\n  $('.listing-result').each((i, el) => {\n    const property = {};",
+      "id": "e54d850ca2cb41c5a869936baad2163f"
+    },
+    "ae64416d43bc4a61b2783d1b7067b9de": {
+      "label": true,
+      "text": "const App = () => {\n  const [list1, setList1] = useState([\n    { id: 1, text: \"Item 1\" },\n    { id: 2, text: \"Item 2\" },\n    { id: 3, text: \"Item 3\" }\n  ]);\n  const [list2, setList2] = useState([\n    { id: 4, text: \"Item 4\" },\n    { id: 5, text: \"Item 5\" }\n  ]);\n\n  const onDragStart = (event, source) => {\n    event.dataTransfer.setData(\"source\", source);\n  };",
+      "id": "ae64416d43bc4a61b2783d1b7067b9de"
+    },
+    "5b6b91512f014660bc48d8527b3ca226": {
+      "label": true,
+      "text": "```javascript\nimport React, { useState } from 'react';\n\nconst App = () => {\n  const [items1, setItems1] = useState(['Item 1', 'Item 2', 'Item 3']);\n  const [items2, setItems2] = useState([]);",
+      "id": "5b6b91512f014660bc48d8527b3ca226"
+    },
+    "c751dfc325414603a16ac65e2fa62fd7": {
+      "label": false,
+      "text": "Detailed Instructions: In this task, you are given an input list. A list contains several comma-separated items written within brackets. You need to return the position of all the alphabetical elements in the given list in order. Assume the position of the 1st element to be 1. Return -1 if no alphabetical element is in the list.\nQ: ['g', '7171', 'v', 'i', 'f', 'c']\nA:",
+      "id": "c751dfc325414603a16ac65e2fa62fd7"
+    },
+    "0310318744f1425e88cdd053773681ca": {
+      "label": false,
+      "text": "In this task, you are given an input list. A list contains several comma-separated items written within brackets. You need to return the position of all the alphabetical elements in the given list in order. Assume the position of the 1st element to be 1. Return -1 if no alphabetical element is in the list.",
+      "id": "0310318744f1425e88cdd053773681ca"
+    },
+    "8d6eb8f1aac745359540c9f454aa9a58": {
+      "label": false,
+      "text": "not how you reconcile with your estranged wife,\u201d wrote Vulture.",
+      "id": "8d6eb8f1aac745359540c9f454aa9a58"
+    }
+  },
+  "version": 62,
+  "description": "Source code for a programming language."
+}

lilac/config.py

@@ -0,0 +1,268 @@
+"""Configurations for a dataset run."""
+
+import json
+import pathlib
+from typing import TYPE_CHECKING, Any, Optional, Union
+
+import yaml
+
+if TYPE_CHECKING:
+  from pydantic.typing import AbstractSetIntStr, MappingIntStrAny
+
+from pydantic import BaseModel, Extra, ValidationError, validator
+
+from .schema import Path, PathTuple, normalize_path
+from .signal import Signal, TextEmbeddingSignal, get_signal_by_type, resolve_signal
+from .sources.source import Source
+from .sources.source_registry import resolve_source
+
+CONFIG_FILENAME = 'config.yml'
+
+
+def _serializable_path(path: PathTuple) -> Union[str, list]:
+  if len(path) == 1:
+    return path[0]
+  return list(path)
+
+
+class SignalConfig(BaseModel):
+  """Configures a signal on a source path."""
+  path: PathTuple
+  signal: Signal
+
+  class Config:
+    extra = Extra.forbid
+
+  @validator('path', pre=True)
+  def parse_path(cls, path: Path) -> PathTuple:
+    """Parse a path."""
+    return normalize_path(path)
+
+  @validator('signal', pre=True)
+  def parse_signal(cls, signal: dict) -> Signal:
+    """Parse a signal to its specific subclass instance."""
+    return resolve_signal(signal)
+
+  def dict(
+    self,
+    *,
+    include: Optional[Union['AbstractSetIntStr', 'MappingIntStrAny']] = None,
+    exclude: Optional[Union['AbstractSetIntStr', 'MappingIntStrAny']] = None,
+    by_alias: bool = False,
+    skip_defaults: Optional[bool] = None,
+    exclude_unset: bool = False,
+    exclude_defaults: bool = False,
+    exclude_none: bool = False,
+  ) -> dict[str, Any]:
+    """Override the default dict method to simplify the path tuples.
+
+    This is required to remove the python-specific tuple dump in the yaml file.
+    """
+    res = super().dict(
+      include=include,
+      exclude=exclude,
+      by_alias=by_alias,
+      skip_defaults=skip_defaults,
+      exclude_unset=exclude_unset,
+      exclude_defaults=exclude_defaults,
+      exclude_none=exclude_none)
+    res['path'] = _serializable_path(res['path'])
+    return res
+
+
+class EmbeddingConfig(BaseModel):
+  """Configures an embedding on a source path."""
+  path: PathTuple
+  embedding: str
+
+  class Config:
+    extra = Extra.forbid
+
+  def dict(
+    self,
+    *,
+    include: Optional[Union['AbstractSetIntStr', 'MappingIntStrAny']] = None,
+    exclude: Optional[Union['AbstractSetIntStr', 'MappingIntStrAny']] = None,
+    by_alias: bool = False,
+    skip_defaults: Optional[bool] = None,
+    exclude_unset: bool = False,
+    exclude_defaults: bool = False,
+    exclude_none: bool = False,
+  ) -> dict[str, Any]:
+    """Override the default dict method to simplify the path tuples.
+
+    This is required to remove the python-specific tuple dump in the yaml file.
+    """
+    res = super().dict(
+      include=include,
+      exclude=exclude,
+      by_alias=by_alias,
+      skip_defaults=skip_defaults,
+      exclude_unset=exclude_unset,
+      exclude_defaults=exclude_defaults,
+      exclude_none=exclude_none)
+    res['path'] = _serializable_path(res['path'])
+    return res
+
+  @validator('path', pre=True)
+  def parse_path(cls, path: Path) -> PathTuple:
+    """Parse a path."""
+    return normalize_path(path)
+
+  @validator('embedding', pre=True)
+  def validate_embedding(cls, embedding: str) -> str:
+    """Validate the embedding is registered."""
+    get_signal_by_type(embedding, TextEmbeddingSignal)
+    return embedding
+
+
+class DatasetUISettings(BaseModel):
+  """The UI persistent settings for a dataset."""
+  media_paths: list[PathTuple] = []
+  markdown_paths: list[PathTuple] = []
+
+  class Config:
+    extra = Extra.forbid
+
+  @validator('media_paths', pre=True)
+  def parse_media_paths(cls, media_paths: list) -> list:
+    """Parse a path, ensuring it is a tuple."""
+    return [normalize_path(path) for path in media_paths]
+
+  def dict(
+    self,
+    *,
+    include: Optional[Union['AbstractSetIntStr', 'MappingIntStrAny']] = None,
+    exclude: Optional[Union['AbstractSetIntStr', 'MappingIntStrAny']] = None,
+    by_alias: bool = False,
+    skip_defaults: Optional[bool] = None,
+    exclude_unset: bool = False,
+    exclude_defaults: bool = False,
+    exclude_none: bool = False,
+  ) -> dict[str, Any]:
+    """Override the default dict method to simplify the path tuples.
+
+    This is required to remove the python-specific tuple dump in the yaml file.
+    """
+    # TODO(nsthorat): Migrate this to @field_serializer when we upgrade to pydantic v2.
+    res = super().dict(
+      include=include,
+      exclude=exclude,
+      by_alias=by_alias,
+      skip_defaults=skip_defaults,
+      exclude_unset=exclude_unset,
+      exclude_defaults=exclude_defaults,
+      exclude_none=exclude_none)
+    if 'media_paths' in res:
+      res['media_paths'] = [_serializable_path(path) for path in res['media_paths']]
+    if 'markdown_paths' in res:
+      res['markdown_paths'] = [_serializable_path(path) for path in res['markdown_paths']]
+    return res
+
+
+class DatasetSettings(BaseModel):
+  """The persistent settings for a dataset."""
+  ui: Optional[DatasetUISettings] = None
+  preferred_embedding: Optional[str] = None
+
+  class Config:
+    extra = Extra.forbid
+
+
+class DatasetConfig(BaseModel):
+  """Configures a dataset with a source and transformations."""
+  # The namespace and name of the dataset.
+  namespace: str
+  name: str
+  # Tags to organize datasets.
+  tags: list[str] = []
+
+  # The source configuration.
+  source: Source
+
+  # Model configuration: embeddings and signals on paths.
+  embeddings: list[EmbeddingConfig] = []
+  # When defined, uses this list of signals instead of running all signals.
+  signals: list[SignalConfig] = []
+
+  # Dataset settings, default embeddings and UI settings like media paths.
+  settings: Optional[DatasetSettings] = None
+
+  class Config:
+    extra = Extra.forbid
+
+  @validator('source', pre=True)
+  def parse_source(cls, source: dict) -> Source:
+    """Parse a source to its specific subclass instance."""
+    return resolve_source(source)
+
+
+class Config(BaseModel):
+  """Configures a set of datasets for a lilac instance."""
+  datasets: list[DatasetConfig]
+
+  # When defined, uses this list of signals to run over every dataset, over all media paths, unless
+  # signals is overridden by a specific dataset.
+  signals: list[Signal] = []
+
+  # A list of embeddings to compute the model caches for, for all concepts.
+  concept_model_cache_embeddings: list[str] = []
+
+  class Config:
+    extra = Extra.forbid
+
+  @validator('signals', pre=True)
+  def parse_signal(cls, signals: list[dict]) -> list[Signal]:
+    """Parse alist of signals to their specific subclass instances."""
+    return [resolve_signal(signal) for signal in signals]
+
+
+def read_config(config_path: str) -> Config:
+  """Reads a config file.
+
+  The config file can either be a `Config` or a `DatasetConfig`.
+
+  The result is always a `Config` object. If the input is a `DatasetConfig`, the config will just
+  contain a single dataset.
+  """
+  config_ext = pathlib.Path(config_path).suffix
+  if config_ext in ['.yml', '.yaml']:
+    with open(config_path, 'r') as f:
+      config_dict = yaml.safe_load(f)
+  elif config_ext in ['.json']:
+    with open(config_path, 'r') as f:
+      config_dict = json.load(f)
+  else:
+    raise ValueError(f'Unsupported config file extension: {config_ext}')
+
+  config: Optional[Config] = None
+  is_config = True
+  try:
+    config = Config(**config_dict)
+  except ValidationError:
+    is_config = False
+
+  if not is_config:
+    try:
+      dataset_config = DatasetConfig(**config_dict)
+      config = Config(datasets=[dataset_config])
+    except ValidationError as error:
+      raise ValidationError(
+        'Config is not a valid `Config` or `DatasetConfig`', model=DatasetConfig) from error
+  assert config is not None
+
+  return config
+
+
+class LilacHuggingFaceDataset(BaseModel):
+  """A huggingface dataset that powers the demo."""
+  hf_dataset_repo_id: str
+  lilac_namespace: str
+  lilac_name: str
+
+
+class DemoConfig(BaseModel):
+  """Configures a hosted demo."""
+
+  # A list of huggingface dataset repositories that power the demo.
+  lilac_hf_datasets: list[LilacHuggingFaceDataset] = []

lilac/conftest.py

@@ -0,0 +1,28 @@
+"""Fixtures for dataset tests."""
+import os
+import pathlib
+from typing import Generator, Optional, Type
+
+import pytest
+from pytest_mock import MockerFixture
+
+from .data.dataset import Dataset
+from .data.dataset_duckdb import DatasetDuckDB
+from .data.dataset_test_utils import make_dataset
+from .db_manager import set_default_dataset_cls
+from .schema import Item, Schema
+
+
+@pytest.fixture(scope='function', params=[DatasetDuckDB])
+def make_test_data(tmp_path: pathlib.Path, mocker: MockerFixture,
+                   request: pytest.FixtureRequest) -> Generator:
+  """A pytest fixture for creating temporary test datasets."""
+  mocker.patch.dict(os.environ, {'LILAC_DATA_PATH': str(tmp_path)})
+  dataset_cls: Type[Dataset] = request.param
+  set_default_dataset_cls(dataset_cls)
+
+  def _make_test_data(items: list[Item], schema: Optional[Schema] = None) -> Dataset:
+    return make_dataset(dataset_cls, tmp_path, items, schema)
+
+  # Return the factory for datasets that test methods can use.
+  yield _make_test_data

lilac/data/__init__.py

@@ -0,0 +1,25 @@
+from .dataset import (
+  BinaryOp,
+  Column,
+  ConceptSearch,
+  Dataset,
+  Filter,
+  FilterLike,
+  KeywordSearch,
+  ListOp,
+  SemanticSearch,
+  UnaryOp,
+)
+
+__all__ = [
+  'Column',
+  'KeywordSearch',
+  'ConceptSearch',
+  'SemanticSearch',
+  'Filter',
+  'UnaryOp',
+  'BinaryOp',
+  'ListOp',
+  'Dataset',
+  'FilterLike',
+]

lilac/data/dataset.py

@@ -0,0 +1,510 @@
+"""The interface for the database."""
+from __future__ import annotations
+
+import abc
+import enum
+import pathlib
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime
+from typing import Any, Iterator, Literal, Optional, Sequence, Union
+
+import pandas as pd
+from pydantic import (
+  BaseModel,
+  StrictBool,
+  StrictBytes,
+  StrictFloat,
+  StrictInt,
+  StrictStr,
+  validator,
+)
+from typing_extensions import TypeAlias
+
+from lilac.signals.concept_scorer import ConceptSignal
+
+from ..auth import UserInfo
+from ..config import DatasetConfig, DatasetSettings, DatasetUISettings
+from ..schema import (
+  PATH_WILDCARD,
+  ROWID,
+  VALUE_KEY,
+  Bin,
+  DataType,
+  Path,
+  PathTuple,
+  Schema,
+  normalize_path,
+)
+from ..signal import Signal, TextEmbeddingSignal, get_signal_by_type, resolve_signal
+from ..tasks import TaskStepId
+
+# Threshold for rejecting certain queries (e.g. group by) for columns with large cardinality.
+TOO_MANY_DISTINCT = 500_000
+SAMPLE_AVG_TEXT_LENGTH = 1000
+MAX_TEXT_LEN_DISTINCT_COUNT = 250
+
+
+class SelectRowsResult:
+  """The result of a select rows query."""
+
+  def __init__(self, df: pd.DataFrame, total_num_rows: int) -> None:
+    """Initialize the result."""
+    self._df = df
+    self.total_num_rows = total_num_rows
+
+  def __iter__(self) -> Iterator:
+    return (row.to_dict() for _, row in self._df.iterrows())
+
+  def df(self) -> pd.DataFrame:
+    """Convert the result to a pandas DataFrame."""
+    return self._df
+
+
+class StatsResult(BaseModel):
+  """The result of a stats() query."""
+  path: PathTuple
+  # The number of leaf values.
+  total_count: int
+  # The approximate number of distinct leaf values.
+  approx_count_distinct: int
+
+  # Defined for ordinal features.
+  min_val: Optional[Union[float, datetime]] = None
+  max_val: Optional[Union[float, datetime]] = None
+
+  # Defined for text features.
+  avg_text_length: Optional[float] = None
+
+
+class MediaResult(BaseModel):
+  """The result of a media() query."""
+  data: bytes
+
+
+BinaryOp = Literal['equals', 'not_equal', 'greater', 'greater_equal', 'less', 'less_equal']
+UnaryOp = Literal['exists']
+ListOp = Literal['in']
+
+BINARY_OPS = set(['equals', 'not_equal', 'greater', 'greater_equal', 'less', 'less_equal'])
+UNARY_OPS = set(['exists'])
+LIST_OPS = set(['in'])
+
+SearchType = Union[Literal['keyword'], Literal['semantic'], Literal['concept']]
+
+
+class SortOrder(str, enum.Enum):
+  """The sort order for a database query."""
+  DESC = 'DESC'
+  ASC = 'ASC'
+
+
+class GroupsSortBy(str, enum.Enum):
+  """The sort for groups queries.
+
+  Either "count" which sorts by the count of feature value, or "value" which sorts by the
+  feature value itself.
+  """
+  COUNT = 'count'
+  VALUE = 'value'
+
+
+class SortResult(BaseModel):
+  """The information about what is sorted after combining searches and explicit sorts."""
+  # The column that was sorted.
+  path: PathTuple
+  # The sort order.
+  order: SortOrder
+  # The alias of the column if it was aliased.
+  alias: Optional[str] = None
+  # The search index if the sort is by a search.
+  search_index: Optional[int] = None
+
+
+class SearchResultInfo(BaseModel):
+  """The resulting sort order returned by the select rows schema."""
+  # The input path to the search.
+  search_path: PathTuple
+  # The resulting column that was searched.
+  result_path: PathTuple
+  # The alias of the UDF.
+  alias: Optional[str] = None
+
+
+class SelectRowsSchemaUDF(BaseModel):
+  """The UDF for a select rows schema query."""
+  path: PathTuple
+  alias: Optional[str] = None
+
+
+class SelectRowsSchemaResult(BaseModel):
+  """The result of a select rows schema query."""
+  data_schema: Schema
+  udfs: list[SelectRowsSchemaUDF] = []
+  search_results: list[SearchResultInfo] = []
+  sorts: Optional[list[SortResult]] = None
+
+
+class Column(BaseModel):
+  """A column in the dataset."""
+  path: PathTuple
+  alias: Optional[str] = None  # This is the renamed column during querying and response.
+
+  # Defined when the feature is another column.
+  signal_udf: Optional[Signal] = None
+
+  class Config:
+    smart_union = True
+
+  def __init__(self,
+               path: Path,
+               alias: Optional[str] = None,
+               signal_udf: Optional[Signal] = None,
+               **kwargs: Any):
+    """Initialize a column. We override __init__ to allow positional arguments for brevity."""
+    super().__init__(path=normalize_path(path), alias=alias, signal_udf=signal_udf, **kwargs)
+
+  @validator('signal_udf', pre=True)
+  def parse_signal_udf(cls, signal_udf: Optional[dict]) -> Optional[Signal]:
+    """Parse a signal to its specific subclass instance."""
+    if not signal_udf:
+      return None
+    return resolve_signal(signal_udf)
+
+
+ColumnId = Union[Path, Column]
+
+
+class DatasetManifest(BaseModel):
+  """The manifest for a dataset."""
+  namespace: str
+  dataset_name: str
+  data_schema: Schema
+  # Number of items in the dataset.
+  num_items: int
+
+
+def column_from_identifier(column: ColumnId) -> Column:
+  """Create a column from a column identifier."""
+  if isinstance(column, Column):
+    return column.copy()
+  return Column(path=column)
+
+
+FeatureValue = Union[StrictInt, StrictFloat, StrictBool, StrictStr, StrictBytes, datetime]
+FeatureListValue = list[StrictStr]
+BinaryFilterTuple = tuple[Path, BinaryOp, FeatureValue]
+ListFilterTuple = tuple[Path, ListOp, FeatureListValue]
+UnaryFilterTuple = tuple[Path, UnaryOp]
+
+FilterOp = Union[BinaryOp, UnaryOp, ListOp]
+
+
+class SelectGroupsResult(BaseModel):
+  """The result of a select groups query."""
+  too_many_distinct: bool
+  counts: list[tuple[Optional[FeatureValue], int]]
+  bins: Optional[list[Bin]] = None
+
+
+class Filter(BaseModel):
+  """A filter on a column."""
+  path: PathTuple
+  op: FilterOp
+  value: Optional[Union[FeatureValue, FeatureListValue]] = None
+
+
+FilterLike: TypeAlias = Union[Filter, BinaryFilterTuple, UnaryFilterTuple, ListFilterTuple]
+
+SearchValue = StrictStr
+
+
+class KeywordSearch(BaseModel):
+  """A keyword search query on a column."""
+  path: Path
+  query: SearchValue
+  type: Literal['keyword'] = 'keyword'
+
+
+class SemanticSearch(BaseModel):
+  """A semantic search on a column."""
+  path: Path
+  query: SearchValue
+  embedding: str
+  type: Literal['semantic'] = 'semantic'
+
+
+class ConceptSearch(BaseModel):
+  """A concept search query on a column."""
+  path: Path
+  concept_namespace: str
+  concept_name: str
+  embedding: str
+  type: Literal['concept'] = 'concept'
+
+
+Search = Union[ConceptSearch, SemanticSearch, KeywordSearch]
+
+
+class Dataset(abc.ABC):
+  """The database implementation to query a dataset."""
+
+  namespace: str
+  dataset_name: str
+
+  def __init__(self, namespace: str, dataset_name: str):
+    """Initialize a dataset.
+
+    Args:
+      namespace: The dataset namespace.
+      dataset_name: The dataset name.
+    """
+    self.namespace = namespace
+    self.dataset_name = dataset_name
+
+  @abc.abstractmethod
+  def delete(self) -> None:
+    """Deletes the dataset."""
+    pass
+
+  @abc.abstractmethod
+  def manifest(self) -> DatasetManifest:
+    """Return the manifest for the dataset."""
+    pass
+
+  @abc.abstractmethod
+  def config(self) -> DatasetConfig:
+    """Return the dataset config for this dataset."""
+    pass
+
+  @abc.abstractmethod
+  def settings(self) -> DatasetSettings:
+    """Return the persistent settings for the dataset."""
+    pass
+
+  @abc.abstractmethod
+  def update_settings(self, settings: DatasetSettings) -> None:
+    """Update the settings for the dataset."""
+    pass
+
+  @abc.abstractmethod
+  def compute_signal(self,
+                     signal: Signal,
+                     path: Path,
+                     task_step_id: Optional[TaskStepId] = None) -> None:
+    """Compute a signal for a column.
+
+    Args:
+      signal: The signal to compute over the given columns.
+      path: The leaf path to compute the signal on.
+      task_step_id: The TaskManager `task_step_id` for this process run. This is used to update the
+        progress of the task.
+    """
+    pass
+
+  def compute_embedding(self,
+                        embedding: str,
+                        path: Path,
+                        task_step_id: Optional[TaskStepId] = None) -> None:
+    """Compute an embedding for a given field path."""
+    signal = get_signal_by_type(embedding, TextEmbeddingSignal)()
+    self.compute_signal(signal, path, task_step_id)
+
+  def compute_concept(self,
+                      namespace: str,
+                      concept_name: str,
+                      embedding: str,
+                      path: Path,
+                      task_step_id: Optional[TaskStepId] = None) -> None:
+    """Compute concept scores for a given field path."""
+    signal = ConceptSignal(namespace=namespace, concept_name=concept_name, embedding=embedding)
+    self.compute_signal(signal, path, task_step_id)
+
+  @abc.abstractmethod
+  def delete_signal(self, signal_path: Path) -> None:
+    """Delete a computed signal from the dataset.
+
+    Args:
+      signal_path: The path holding the computed data of the signal.
+    """
+    pass
+
+  @abc.abstractmethod
+  def select_groups(
+      self,
+      leaf_path: Path,
+      filters: Optional[Sequence[FilterLike]] = None,
+      sort_by: Optional[GroupsSortBy] = None,
+      sort_order: Optional[SortOrder] = SortOrder.DESC,
+      limit: Optional[int] = None,
+      bins: Optional[Union[Sequence[Bin], Sequence[float]]] = None) -> SelectGroupsResult:
+    """Select grouped columns to power a histogram.
+
+    Args:
+      leaf_path: The leaf path to group by. The path can be a dot-seperated string path, or a tuple
+                 of fields.
+      filters: The filters to apply to the query.
+      sort_by: What to sort by, either "count" or "value".
+      sort_order: The sort order.
+      limit: The maximum number of rows to return.
+      bins: The bins to use when bucketizing a float column.
+
+    Returns
+      A `SelectGroupsResult` iterator where each row is a group.
+    """
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def select_rows(self,
+                  columns: Optional[Sequence[ColumnId]] = None,
+                  searches: Optional[Sequence[Search]] = None,
+                  filters: Optional[Sequence[FilterLike]] = None,
+                  sort_by: Optional[Sequence[Path]] = None,
+                  sort_order: Optional[SortOrder] = SortOrder.DESC,
+                  limit: Optional[int] = 100,
+                  offset: Optional[int] = 0,
+                  task_step_id: Optional[TaskStepId] = None,
+                  resolve_span: bool = False,
+                  combine_columns: bool = False,
+                  user: Optional[UserInfo] = None) -> SelectRowsResult:
+    """Select a set of rows that match the provided filters, analogous to SQL SELECT.
+
+    Args:
+      columns: The columns to select. A column is an instance of `Column` which can either
+        define a path to a feature, or a column with an applied Transform, e.g. a Concept. If none,
+        it selects all columns.
+      searches: The searches to apply to the query.
+      filters: The filters to apply to the query.
+      sort_by: An ordered list of what to sort by. When defined, this is a list of aliases of column
+        names defined by the "alias" field in Column. If no alias is provided for a column, an
+        automatic alias is generated by combining each path element with a "."
+        For example: e.g. ('person', 'name') => person.name. For columns that are transform columns,
+        an alias must be provided explicitly. When sorting by a (nested) list of values, the sort
+        takes the minumum value when `sort_order` is `ASC`, and the maximum value when `sort_order`
+        is `DESC`.
+      sort_order: The sort order.
+      limit: The maximum number of rows to return.
+      offset: The offset to start returning rows from.
+      task_step_id: The TaskManager `task_step_id` for this process run. This is used to update the
+        progress.
+      resolve_span: Whether to resolve the span of the row.
+      combine_columns: Whether to combine columns into a single object. The object will be pruned
+        to only include sub-fields that correspond to the requested columns.
+      user: The authenticated user, if auth is enabled and the user is logged in. This is used to
+        apply ACL to the query, especially for concepts.
+
+    Returns
+      A `SelectRowsResult` iterator with rows of `Item`s.
+    """
+    pass
+
+  @abc.abstractmethod
+  def select_rows_schema(self,
+                         columns: Optional[Sequence[ColumnId]] = None,
+                         sort_by: Optional[Sequence[Path]] = None,
+                         sort_order: Optional[SortOrder] = SortOrder.DESC,
+                         searches: Optional[Sequence[Search]] = None,
+                         combine_columns: bool = False) -> SelectRowsSchemaResult:
+    """Returns the schema of the result of `select_rows` above with the same arguments."""
+    pass
+
+  @abc.abstractmethod
+  def stats(self, leaf_path: Path) -> StatsResult:
+    """Compute stats for a leaf path.
+
+    Args:
+      leaf_path: The leaf path to compute stats for.
+
+    Returns
+      A StatsResult.
+    """
+    pass
+
+  @abc.abstractmethod
+  def media(self, item_id: str, leaf_path: Path) -> MediaResult:
+    """Return the media for a leaf path.
+
+    Args:
+      item_id: The item id to get media for.
+      leaf_path: The leaf path for the media.
+
+    Returns
+      A MediaResult.
+    """
+    pass
+
+  @abc.abstractmethod
+  def to_json(self,
+              filepath: Union[str, pathlib.Path],
+              jsonl: bool = True,
+              columns: Optional[Sequence[ColumnId]] = None) -> None:
+    """Export the dataset to a JSON file.
+
+    Args:
+      filepath: The path to the file to export to.
+      jsonl: Whether to export to JSONL or JSON.
+      columns: The columns to export.
+    """
+    pass
+
+  @abc.abstractmethod
+  def to_pandas(self, columns: Optional[Sequence[ColumnId]] = None) -> pd.DataFrame:
+    """Export the dataset to a pandas DataFrame.
+
+    Args:
+      columns: The columns to export.
+    """
+    pass
+
+  @abc.abstractmethod
+  def to_parquet(self,
+                 filepath: Union[str, pathlib.Path],
+                 columns: Optional[Sequence[ColumnId]] = None) -> None:
+    """Export the dataset to a parquet file.
+
+    Args:
+      filepath: The path to the file to export to.
+      columns: The columns to export.
+    """
+    pass
+
+  @abc.abstractmethod
+  def to_csv(self,
+             filepath: Union[str, pathlib.Path],
+             columns: Optional[Sequence[ColumnId]] = None) -> None:
+    """Export the dataset to a csv file.
+
+    Args:
+      filepath: The path to the file to export to.
+      columns: The columns to export.
+    """
+    pass
+
+
+def default_settings(dataset: Dataset) -> DatasetSettings:
+  """Gets the default settings for a dataset."""
+  schema = dataset.manifest().data_schema
+  leaf_paths = [
+    path for path, field in schema.leafs.items()
+    if field.dtype == DataType.STRING and path != (ROWID,)
+  ]
+  pool = ThreadPoolExecutor()
+  stats: list[StatsResult] = list(pool.map(lambda leaf: dataset.stats(leaf), leaf_paths))
+  sorted_stats = sorted([stat for stat in stats if stat.avg_text_length],
+                        key=lambda stat: stat.avg_text_length or -1.0)
+  media_paths: list[PathTuple] = []
+  if sorted_stats:
+    media_paths = [sorted_stats[-1].path]
+
+  return DatasetSettings(ui=DatasetUISettings(media_paths=media_paths))
+
+
+def make_parquet_id(signal: Signal,
+                    source_path: PathTuple,
+                    is_computed_signal: Optional[bool] = False) -> str:
+  """Return a unique identifier for this parquet table."""
+  # Remove the wildcards from the parquet id since they are implicit.
+  path = [*[p for p in source_path if p != PATH_WILDCARD], signal.key(is_computed_signal)]
+  # Don't use the VALUE_KEY as part of the parquet id to reduce the size of paths.
+  if path[-1] == VALUE_KEY:
+    path = path[:-1]
+  return '.'.join(path)

lilac/data/dataset_duckdb.py

@@ -0,0 +1,1833 @@
+"""The DuckDB implementation of the dataset database."""
+import functools
+import gc
+import glob
+import math
+import os
+import pathlib
+import re
+import shutil
+import threading
+from typing import Any, Iterable, Iterator, Optional, Sequence, Union, cast
+
+import duckdb
+import numpy as np
+import pandas as pd
+import yaml
+from pandas.api.types import is_object_dtype
+from pydantic import BaseModel, validator
+from typing_extensions import override
+
+from ..auth import UserInfo
+from ..batch_utils import deep_flatten, deep_unflatten
+from ..config import CONFIG_FILENAME, DatasetConfig, DatasetSettings, EmbeddingConfig, SignalConfig
+from ..embeddings.vector_store import VectorDBIndex
+from ..env import data_path, env
+from ..schema import (
+  MANIFEST_FILENAME,
+  PATH_WILDCARD,
+  ROWID,
+  TEXT_SPAN_END_FEATURE,
+  TEXT_SPAN_START_FEATURE,
+  VALUE_KEY,
+  Bin,
+  DataType,
+  Field,
+  Item,
+  Path,
+  PathKey,
+  PathTuple,
+  RichData,
+  Schema,
+  SourceManifest,
+  column_paths_match,
+  is_float,
+  is_integer,
+  is_ordinal,
+  is_temporal,
+  normalize_path,
+  signal_type_supports_dtype,
+)
+from ..signal import Signal, TextEmbeddingSignal, VectorSignal, get_signal_by_type, resolve_signal
+from ..signals.concept_labels import ConceptLabelsSignal
+from ..signals.concept_scorer import ConceptSignal
+from ..signals.semantic_similarity import SemanticSimilaritySignal
+from ..signals.substring_search import SubstringSignal
+from ..sources.source import Source
+from ..tasks import TaskStepId, progress
+from ..utils import DebugTimer, get_dataset_output_dir, log, open_file, to_yaml
+from . import dataset
+from .dataset import (
+  BINARY_OPS,
+  LIST_OPS,
+  MAX_TEXT_LEN_DISTINCT_COUNT,
+  SAMPLE_AVG_TEXT_LENGTH,
+  TOO_MANY_DISTINCT,
+  UNARY_OPS,
+  BinaryOp,
+  Column,
+  ColumnId,
+  Dataset,
+  DatasetManifest,
+  FeatureListValue,
+  FeatureValue,
+  Filter,
+  FilterLike,
+  GroupsSortBy,
+  MediaResult,
+  Search,
+  SearchResultInfo,
+  SelectGroupsResult,
+  SelectRowsResult,
+  SelectRowsSchemaResult,
+  SelectRowsSchemaUDF,
+  SortOrder,
+  SortResult,
+  StatsResult,
+  column_from_identifier,
+  make_parquet_id,
+)
+from .dataset_utils import (
+  count_primitives,
+  create_signal_schema,
+  flatten_keys,
+  merge_schemas,
+  schema_contains_path,
+  sparse_to_dense_compute,
+  wrap_in_dicts,
+  write_embeddings_to_disk,
+  write_items_to_parquet,
+)
+
+SIGNAL_MANIFEST_FILENAME = 'signal_manifest.json'
+DATASET_SETTINGS_FILENAME = 'settings.json'
+SOURCE_VIEW_NAME = 'source'
+
+NUM_AUTO_BINS = 15
+
+BINARY_OP_TO_SQL: dict[BinaryOp, str] = {
+  'equals': '=',
+  'not_equal': '!=',
+  'greater': '>',
+  'greater_equal': '>=',
+  'less': '<',
+  'less_equal': '<='
+}
+
+
+class DuckDBSearchUDF(BaseModel):
+  """The transformation of searches to column UDFs."""
+  udf: Column
+  search_path: PathTuple
+  output_path: PathTuple
+  sort: Optional[tuple[PathTuple, SortOrder]] = None
+
+
+class DuckDBSearchUDFs(BaseModel):
+  """The transformation of searches to column UDFs with sorts."""
+  udfs: list[Column]
+  output_paths: list[PathTuple]
+  sorts: list[tuple[PathTuple, SortOrder]]
+
+
+class DatasetDuckDB(Dataset):
+  """The DuckDB implementation of the dataset database."""
+
+  def __init__(self, namespace: str, dataset_name: str, vector_store: str = 'hnsw'):
+    super().__init__(namespace, dataset_name)
+
+    self.dataset_path = get_dataset_output_dir(data_path(), namespace, dataset_name)
+
+    # TODO: Infer the manifest from the parquet files so this is lighter weight.
+    self._source_manifest = read_source_manifest(self.dataset_path)
+    self._signal_manifests: list[SignalManifest] = []
+    self.con = duckdb.connect(database=':memory:')
+
+    # Maps a path and embedding to the vector index. This is lazily generated as needed.
+    self._vector_indices: dict[tuple[PathKey, str], VectorDBIndex] = {}
+    self.vector_store = vector_store
+    self._manifest_lock = threading.Lock()
+
+    self._config_lock = threading.Lock()
+    config_filepath = get_config_filepath(namespace, dataset_name)
+
+    if not os.path.exists(config_filepath):
+      # For backwards compatibility, if the config doesn't exist, create one. This will be out of
+      # sync but allow the server to still boot and update with new config changes.
+      # Make a metaclass so we get a valid `Source` class.
+      source_cls = type('Source_no_source', (Source,), {'name': 'no_source'})
+
+      old_settings_filepath = os.path.join(
+        get_dataset_output_dir(data_path(), namespace, dataset_name), 'settings.json')
+      settings = DatasetSettings()
+      if os.path.exists(old_settings_filepath):
+        with open(old_settings_filepath) as f:
+          settings = DatasetSettings.parse_raw(f.read())
+
+      config = DatasetConfig(
+        namespace=namespace, name=dataset_name, source=source_cls(), settings=settings)
+      with open(get_config_filepath(self.namespace, self.dataset_name), 'w') as f:
+        f.write(to_yaml(config.dict(exclude_none=True, exclude_defaults=True)))
+
+    # Create a join table from all the parquet files.
+    self.manifest()
+
+  @override
+  def delete(self) -> None:
+    """Deletes the dataset."""
+    self.con.close()
+    shutil.rmtree(self.dataset_path, ignore_errors=True)
+
+  def _create_view(self, view_name: str, files: list[str]) -> None:
+    self.con.execute(f"""
+      CREATE OR REPLACE VIEW {_escape_col_name(view_name)} AS (SELECT * FROM read_parquet({files}));
+    """)
+
+  # NOTE: This is cached, but when the latest mtime of any file in the dataset directory changes
+  # the results are invalidated.
+  @functools.cache
+  def _recompute_joint_table(self, latest_mtime_micro_sec: int) -> DatasetManifest:
+    del latest_mtime_micro_sec  # This is used as the cache key.
+    merged_schema = self._source_manifest.data_schema.copy(deep=True)
+    self._signal_manifests = []
+    # Make a joined view of all the column groups.
+    self._create_view(SOURCE_VIEW_NAME,
+                      [os.path.join(self.dataset_path, f) for f in self._source_manifest.files])
+
+    # Add the signal column groups.
+    for root, _, files in os.walk(self.dataset_path):
+      for file in files:
+        if not file.endswith(SIGNAL_MANIFEST_FILENAME):
+          continue
+
+        with open_file(os.path.join(root, file)) as f:
+          signal_manifest = SignalManifest.parse_raw(f.read())
+        self._signal_manifests.append(signal_manifest)
+        signal_files = [os.path.join(root, f) for f in signal_manifest.files]
+        if signal_files:
+          self._create_view(signal_manifest.parquet_id, signal_files)
+
+    merged_schema = merge_schemas([self._source_manifest.data_schema] +
+                                  [m.data_schema for m in self._signal_manifests])
+
+    # The logic below generates the following example query:
+    # CREATE OR REPLACE VIEW t AS (
+    #   SELECT
+    #     source.*,
+    #     "parquet_id1"."root_column" AS "parquet_id1",
+    #     "parquet_id2"."root_column" AS "parquet_id2"
+    #   FROM source JOIN "parquet_id1" USING (rowid,) JOIN "parquet_id2" USING (rowid,)
+    # );
+    # NOTE: "root_column" for each signal is defined as the top-level column.
+    select_sql = ', '.join([f'{SOURCE_VIEW_NAME}.*'] + [(
+      f'{_escape_col_name(manifest.parquet_id)}.{_escape_col_name(_root_column(manifest))} '
+      f'AS {_escape_col_name(manifest.parquet_id)}')
+                                                        for manifest in self._signal_manifests
+                                                        if manifest.files])
+    join_sql = ' '.join([SOURCE_VIEW_NAME] + [
+      f'LEFT JOIN {_escape_col_name(manifest.parquet_id)} USING ({ROWID})'
+      for manifest in self._signal_manifests
+      if manifest.files
+    ])
+    view_or_table = 'TABLE'
+    use_views = env('DUCKDB_USE_VIEWS', 0) or 0
+    if int(use_views):
+      view_or_table = 'VIEW'
+    sql_cmd = f"""CREATE OR REPLACE {view_or_table} t AS (SELECT {select_sql} FROM {join_sql})"""
+    self.con.execute(sql_cmd)
+
+    # Get the total size of the table.
+    size_query = 'SELECT COUNT() as count FROM t'
+    size_query_result = cast(Any, self._query(size_query)[0])
+    num_items = cast(int, size_query_result[0])
+
+    return DatasetManifest(
+      namespace=self.namespace,
+      dataset_name=self.dataset_name,
+      data_schema=merged_schema,
+      num_items=num_items)
+
+  @override
+  def manifest(self) -> DatasetManifest:
+    # Use the latest modification time of all files under the dataset path as the cache key for
+    # re-computing the manifest and the joined view.
+    with self._manifest_lock:
+      all_dataset_files = glob.iglob(os.path.join(self.dataset_path, '**'), recursive=True)
+      latest_mtime = max(map(os.path.getmtime, all_dataset_files))
+      latest_mtime_micro_sec = int(latest_mtime * 1e6)
+      return self._recompute_joint_table(latest_mtime_micro_sec)
+
+  def _update_config(self,
+                     settings: Optional[DatasetSettings] = None,
+                     signals: Optional[list[SignalConfig]] = None,
+                     embeddings: Optional[list[EmbeddingConfig]] = None) -> None:
+    with self._config_lock:
+      config = self.config()
+
+      if settings is not None:
+        config.settings = settings
+
+      if signals is not None:
+        # Update the config with the new signal, if the new signal has not already been added (this
+        # can happen if a signal is re-computed)
+        update_config = True
+        for signal_config in signals:
+          for existing_signal in config.signals:
+            if (existing_signal.path == signal_config.path and
+                existing_signal.signal.dict() == signal_config.signal.dict()):
+              update_config = False
+              break
+          if update_config:
+            config.signals.append(signal_config)
+
+      if embeddings is not None:
+        # Update the config with the new signal, if the new signal has not already been added (this
+        # can happen if a signal is re-computed)
+        update_config = True
+        for embedding_config in embeddings:
+          for existing_embedding in config.embeddings:
+            if (existing_embedding.path == embedding_config.path and
+                existing_embedding.embedding == embedding_config.embedding):
+              update_config = False
+              break
+          if update_config:
+            config.embeddings.append(embedding_config)
+
+      with open(get_config_filepath(self.namespace, self.dataset_name), 'w') as f:
+        f.write(to_yaml(config.dict(exclude_none=True, exclude_defaults=True)))
+
+  @override
+  def config(self) -> DatasetConfig:
+    config_filepath = get_config_filepath(self.namespace, self.dataset_name)
+    with open(config_filepath) as f:
+      return DatasetConfig(**yaml.safe_load(f))
+
+  @override
+  def settings(self) -> DatasetSettings:
+    # Settings should always have a default.
+    settings = self.config().settings
+    assert settings is not None
+    return settings
+
+  @override
+  def update_settings(self, settings: DatasetSettings) -> None:
+    self._update_config(settings)
+
+  def count(self, filters: Optional[list[FilterLike]] = None) -> int:
+    """Count the number of rows."""
+    raise NotImplementedError('count is not yet implemented for DuckDB.')
+
+  def _get_vector_db_index(self, embedding: str, path: PathTuple) -> VectorDBIndex:
+    # Refresh the manifest to make sure we have the latest signal manifests.
+    self.manifest()
+    index_key = (path, embedding)
+    if index_key in self._vector_indices:
+      return self._vector_indices[index_key]
+
+    manifests = [
+      m for m in self._signal_manifests
+      if schema_contains_path(m.data_schema, path) and m.vector_store and m.signal.name == embedding
+    ]
+    if not manifests:
+      raise ValueError(f'No embedding found for path {path}.')
+    if len(manifests) > 1:
+      raise ValueError(f'Multiple embeddings found for path {path}. Got: {manifests}')
+    manifest = manifests[0]
+    if not manifest.vector_store:
+      raise ValueError(f'Signal manifest for path {path} is not an embedding. '
+                       f'Got signal manifest: {manifest}')
+
+    base_path = os.path.join(self.dataset_path, _signal_dir(manifest.enriched_path),
+                             manifest.signal.name)
+    path_id = f'{self.namespace}/{self.dataset_name}:{path}'
+    with DebugTimer(f'Loading vector store "{manifest.vector_store}" for {path_id}'
+                    f' with embedding "{embedding}"'):
+      vector_index = VectorDBIndex(manifest.vector_store)
+      vector_index.load(base_path)
+    # Cache the vector index.
+    self._vector_indices[index_key] = vector_index
+    return vector_index
+
+  @override
+  def compute_signal(self,
+                     signal: Signal,
+                     path: Path,
+                     task_step_id: Optional[TaskStepId] = None) -> None:
+    if isinstance(signal, TextEmbeddingSignal):
+      return self.compute_embedding(signal.name, path, task_step_id)
+    source_path = normalize_path(path)
+    manifest = self.manifest()
+
+    if task_step_id is None:
+      # Make a dummy task step so we report progress via tqdm.
+      task_step_id = ('', 0)
+
+    # The manifest may have changed after computing the dependencies.
+    manifest = self.manifest()
+
+    signal_col = Column(path=source_path, alias='value', signal_udf=signal)
+    select_rows_result = self.select_rows([ROWID, signal_col],
+                                          task_step_id=task_step_id,
+                                          resolve_span=True)
+    df = select_rows_result.df()
+    values = df['value']
+
+    enriched_path = _col_destination_path(signal_col, is_computed_signal=True)
+    spec = _split_path_into_subpaths_of_lists(enriched_path)
+    output_dir = os.path.join(self.dataset_path, _signal_dir(enriched_path))
+    signal_schema = create_signal_schema(signal, source_path, manifest.data_schema)
+    enriched_signal_items = cast(Iterable[Item], wrap_in_dicts(values, spec))
+    for rowid, item in zip(df[ROWID], enriched_signal_items):
+      item[ROWID] = rowid
+
+    enriched_signal_items = list(enriched_signal_items)
+    parquet_filename, _ = write_items_to_parquet(
+      items=enriched_signal_items,
+      output_dir=output_dir,
+      schema=signal_schema,
+      filename_prefix='data',
+      shard_index=0,
+      num_shards=1)
+
+    signal_manifest = SignalManifest(
+      files=[parquet_filename],
+      data_schema=signal_schema,
+      signal=signal,
+      enriched_path=source_path,
+      parquet_id=make_parquet_id(signal, source_path, is_computed_signal=True))
+    signal_manifest_filepath = os.path.join(output_dir, SIGNAL_MANIFEST_FILENAME)
+    with open_file(signal_manifest_filepath, 'w') as f:
+      f.write(signal_manifest.json(exclude_none=True, indent=2))
+
+    self._update_config(signals=[SignalConfig(path=source_path, signal=signal)])
+
+    log(f'Wrote signal output to {output_dir}')
+
+  @override
+  def compute_embedding(self,
+                        embedding: str,
+                        path: Path,
+                        task_step_id: Optional[TaskStepId] = None) -> None:
+    source_path = normalize_path(path)
+    manifest = self.manifest()
+
+    if task_step_id is None:
+      # Make a dummy task step so we report progress via tqdm.
+      task_step_id = ('', 0)
+
+    signal = get_signal_by_type(embedding, TextEmbeddingSignal)()
+    signal_col = Column(path=source_path, alias='value', signal_udf=signal)
+    select_rows_result = self.select_rows([ROWID, signal_col],
+                                          task_step_id=task_step_id,
+                                          resolve_span=True)
+    df = select_rows_result.df()
+    values = df['value']
+
+    enriched_path = _col_destination_path(signal_col, is_computed_signal=True)
+    output_dir = os.path.join(self.dataset_path, _signal_dir(enriched_path))
+    signal_schema = create_signal_schema(signal, source_path, manifest.data_schema)
+
+    write_embeddings_to_disk(
+      vector_store=self.vector_store, rowids=df[ROWID], signal_items=values, output_dir=output_dir)
+
+    del select_rows_result, df, values
+    gc.collect()
+
+    signal_manifest = SignalManifest(
+      files=[],
+      data_schema=signal_schema,
+      signal=signal,
+      enriched_path=source_path,
+      parquet_id=make_parquet_id(signal, source_path, is_computed_signal=True),
+      vector_store=self.vector_store)
+    signal_manifest_filepath = os.path.join(output_dir, SIGNAL_MANIFEST_FILENAME)
+
+    with open_file(signal_manifest_filepath, 'w') as f:
+      f.write(signal_manifest.json(exclude_none=True, indent=2))
+
+    self._update_config(embeddings=[EmbeddingConfig(path=source_path, embedding=embedding)])
+
+    log(f'Wrote embedding index to {output_dir}')
+
+  @override
+  def delete_signal(self, signal_path: Path) -> None:
+    signal_path = normalize_path(signal_path)
+    manifest = self.manifest()
+    if not manifest.data_schema.has_field(signal_path):
+      raise ValueError(f'Unknown signal path: {signal_path}')
+
+    output_dir = os.path.join(self.dataset_path, _signal_dir(signal_path))
+    shutil.rmtree(output_dir, ignore_errors=True)
+
+  def _validate_filters(self, filters: Sequence[Filter], col_aliases: dict[str, PathTuple],
+                        manifest: DatasetManifest) -> None:
+    for filter in filters:
+      if filter.path[0] in col_aliases:
+        # This is a filter on a column alias, which is always allowed.
+        continue
+
+      current_field = Field(fields=manifest.data_schema.fields)
+      if filter.path == (ROWID,):
+        return
+      for path_part in filter.path:
+        if path_part == VALUE_KEY:
+          if not current_field.dtype:
+            raise ValueError(f'Unable to filter on path {filter.path}. The field has no value.')
+          continue
+        if current_field.fields:
+          if path_part not in current_field.fields:
+            raise ValueError(f'Unable to filter on path {filter.path}. '
+                             f'Path part "{path_part}" not found in the dataset.')
+          current_field = current_field.fields[str(path_part)]
+          continue
+        elif current_field.repeated_field:
+          current_field = current_field.repeated_field
+          continue
+        else:
+          raise ValueError(f'Unable to filter on path {filter.path}. '
+                           f'Path part "{path_part}" is not defined on a primitive value.')
+
+      while current_field.repeated_field:
+        current_field = current_field.repeated_field
+        filter.path = (*filter.path, PATH_WILDCARD)
+
+      if not current_field.dtype:
+        raise ValueError(f'Unable to filter on path {filter.path}. The field has no value.')
+
+  def _validate_udfs(self, udf_cols: Sequence[Column], source_schema: Schema) -> None:
+    for col in udf_cols:
+      path = col.path
+
+      # Signal transforms must operate on a leaf field.
+      leaf = source_schema.leafs.get(path)
+      if not leaf or not leaf.dtype:
+        raise ValueError(f'Leaf "{path}" not found in dataset. '
+                         'Signal transforms must operate on a leaf field.')
+
+      # Signal transforms must have the same dtype as the leaf field.
+      signal = cast(Signal, col.signal_udf)
+      if not signal_type_supports_dtype(signal.input_type, leaf.dtype):
+        raise ValueError(f'Leaf "{path}" has dtype "{leaf.dtype}" which is not supported '
+                         f'by "{signal.key()}" with signal input type "{signal.input_type}".')
+
+  def _validate_selection(self, columns: Sequence[Column], select_schema: Schema) -> None:
+    # Validate all the columns and make sure they exist in the `select_schema`.
+    for column in columns:
+      current_field = Field(fields=select_schema.fields)
+      path = column.path
+      if path == (ROWID,):
+        return
+      for path_part in path:
+        if path_part == VALUE_KEY:
+          if not current_field.dtype:
+            raise ValueError(f'Unable to select path {path}. The field that has no value.')
+          continue
+        if current_field.fields:
+          if path_part not in current_field.fields:
+            raise ValueError(f'Unable to select path {path}. '
+                             f'Path part "{path_part}" not found in the dataset.')
+          current_field = current_field.fields[path_part]
+          continue
+        elif current_field.repeated_field:
+          if path_part.isdigit():
+            raise ValueError(f'Unable to select path {path}. Selecting a specific index of '
+                             'a repeated field is currently not supported.')
+          if path_part != PATH_WILDCARD:
+            raise ValueError(f'Unable to select path {path}. '
+                             f'Path part "{path_part}" should be a wildcard.')
+          current_field = current_field.repeated_field
+        elif not current_field.dtype:
+          raise ValueError(f'Unable to select path {path}. '
+                           f'Path part "{path_part}" is not defined on a primitive value.')
+
+  def _validate_columns(self, columns: Sequence[Column], source_schema: Schema,
+                        select_schema: Schema) -> None:
+    udf_cols = [col for col in columns if col.signal_udf]
+    self._validate_udfs(udf_cols, source_schema)
+    self._validate_selection(columns, select_schema)
+
+  def _validate_sort_path(self, path: PathTuple, schema: Schema) -> None:
+    current_field = Field(fields=schema.fields)
+    if path == (ROWID,):
+      return
+    for path_part in path:
+      if path_part == VALUE_KEY:
+        if not current_field.dtype:
+          raise ValueError(f'Unable to sort by path {path}. The field that has no value.')
+        continue
+      if current_field.fields:
+        if path_part not in current_field.fields:
+          raise ValueError(f'Unable to sort by path {path}. '
+                           f'Path part "{path_part}" not found in the dataset.')
+        current_field = current_field.fields[path_part]
+        continue
+      elif current_field.repeated_field:
+        if path_part.isdigit():
+          raise ValueError(f'Unable to sort by path {path}. Selecting a specific index of '
+                           'a repeated field is currently not supported.')
+        if path_part != PATH_WILDCARD:
+          raise ValueError(f'Unable to sort by path {path}. '
+                           f'Path part "{path_part}" should be a wildcard.')
+        current_field = current_field.repeated_field
+      elif not current_field.dtype:
+        raise ValueError(f'Unable to sort by path {path}. '
+                         f'Path part "{path_part}" is not defined on a primitive value.')
+    if not current_field.dtype:
+      raise ValueError(f'Unable to sort by path {path}. The field has no value.')
+
+  @override
+  @functools.cache  # Cache stats for leaf paths since we ask on every dataset page refresh.
+  def stats(self, leaf_path: Path) -> StatsResult:
+    if not leaf_path:
+      raise ValueError('leaf_path must be provided')
+    path = normalize_path(leaf_path)
+    manifest = self.manifest()
+    leaf = manifest.data_schema.get_field(path)
+    # Find the inner-most leaf in case this field is repeated.
+    while leaf.repeated_field:
+      leaf = leaf.repeated_field
+      path = (*path, PATH_WILDCARD)
+
+    if not leaf.dtype:
+      raise ValueError(f'Leaf "{path}" not found in dataset')
+
+    duckdb_path = self._leaf_path_to_duckdb_path(path, manifest.data_schema)
+    inner_select = _select_sql(
+      duckdb_path, flatten=True, unnest=True, span_from=self._get_span_from(path, manifest))
+
+    # Compute the average length of text fields.
+    avg_text_length: Optional[int] = None
+    if leaf.dtype in (DataType.STRING, DataType.STRING_SPAN):
+      avg_length_query = f"""
+        SELECT avg(length(val))
+        FROM (SELECT {inner_select} AS val FROM t) USING SAMPLE {SAMPLE_AVG_TEXT_LENGTH};
+      """
+      row = self._query(avg_length_query)[0]
+      if row[0] is not None:
+        avg_text_length = int(row[0])
+
+    total_count_query = f'SELECT count(val) FROM (SELECT {inner_select} as val FROM t)'
+    total_count = int(self._query(total_count_query)[0][0])
+
+    # Compute approximate count by sampling the data to avoid OOM.
+    if avg_text_length and avg_text_length > MAX_TEXT_LEN_DISTINCT_COUNT:
+      # Assume that every text field is unique.
+      approx_count_distinct = manifest.num_items
+    elif leaf.dtype == DataType.BOOLEAN:
+      approx_count_distinct = 2
+    else:
+      sample_size = TOO_MANY_DISTINCT
+      approx_count_query = f"""
+        SELECT approx_count_distinct(val) as approxCountDistinct
+        FROM (SELECT {inner_select} AS val FROM t) USING SAMPLE {sample_size};
+      """
+      row = self._query(approx_count_query)[0]
+      approx_count_distinct = int(row[0])
+
+      # Adjust the counts for the sample size.
+      factor = max(1, total_count / sample_size)
+      approx_count_distinct = round(approx_count_distinct * factor)
+
+    result = StatsResult(
+      path=path,
+      total_count=total_count,
+      approx_count_distinct=approx_count_distinct,
+      avg_text_length=avg_text_length)
+
+    # Compute min/max values for ordinal leafs, without sampling the data.
+    if is_ordinal(leaf.dtype):
+      min_max_query = f"""
+        SELECT MIN(val) AS minVal, MAX(val) AS maxVal
+        FROM (SELECT {inner_select} as val FROM t)
+        {'WHERE NOT isnan(val)' if is_float(leaf.dtype) else ''}
+      """
+      row = self._query(min_max_query)[0]
+      result.min_val, result.max_val = row
+
+    return result
+
+  @override
+  def select_groups(
+      self,
+      leaf_path: Path,
+      filters: Optional[Sequence[FilterLike]] = None,
+      sort_by: Optional[GroupsSortBy] = GroupsSortBy.COUNT,
+      sort_order: Optional[SortOrder] = SortOrder.DESC,
+      limit: Optional[int] = None,
+      bins: Optional[Union[Sequence[Bin], Sequence[float]]] = None) -> SelectGroupsResult:
+    if not leaf_path:
+      raise ValueError('leaf_path must be provided')
+    path = normalize_path(leaf_path)
+    manifest = self.manifest()
+    leaf = manifest.data_schema.get_field(path)
+    # Find the inner-most leaf in case this field is repeated.
+    while leaf.repeated_field:
+      leaf = leaf.repeated_field
+      path = (*path, PATH_WILDCARD)
+
+    if not leaf.dtype:
+      raise ValueError(f'Leaf "{path}" not found in dataset')
+
+    inner_val = 'inner_val'
+    outer_select = inner_val
+    # Normalize the bins to be `list[Bin]`.
+    named_bins = _normalize_bins(bins or leaf.bins)
+    stats = self.stats(leaf_path)
+
+    leaf_is_float = is_float(leaf.dtype)
+    leaf_is_integer = is_integer(leaf.dtype)
+    if not leaf.categorical and (leaf_is_float or leaf_is_integer):
+      if named_bins is None:
+        # Auto-bin.
+        named_bins = _auto_bins(stats, NUM_AUTO_BINS)
+
+      sql_bounds = []
+      for label, start, end in named_bins:
+        if start is None:
+          start = cast(float, "'-Infinity'")
+        if end is None:
+          end = cast(float, "'Infinity'")
+        sql_bounds.append(f"('{label}', {start}, {end})")
+
+      bin_index_col = 'col0'
+      bin_min_col = 'col1'
+      bin_max_col = 'col2'
+      is_nan_filter = f'NOT isnan({inner_val}) AND' if leaf_is_float else ''
+
+      # We cast the field to `double` so binning works for both `float` and `int` fields.
+      outer_select = f"""(
+        SELECT {bin_index_col} FROM (
+          VALUES {', '.join(sql_bounds)}
+        ) WHERE {is_nan_filter}
+           {inner_val}::DOUBLE >= {bin_min_col} AND {inner_val}::DOUBLE < {bin_max_col}
+      )"""
+    else:
+      if stats.approx_count_distinct >= dataset.TOO_MANY_DISTINCT:
+        return SelectGroupsResult(too_many_distinct=True, counts=[], bins=named_bins)
+
+    count_column = 'count'
+    value_column = 'value'
+
+    limit_query = f'LIMIT {limit}' if limit else ''
+    duckdb_path = self._leaf_path_to_duckdb_path(path, manifest.data_schema)
+    inner_select = _select_sql(
+      duckdb_path, flatten=True, unnest=True, span_from=self._get_span_from(path, manifest))
+
+    filters, _ = self._normalize_filters(filters, col_aliases={}, udf_aliases={}, manifest=manifest)
+    filter_queries = self._create_where(manifest, filters, searches=[])
+
+    where_query = ''
+    if filter_queries:
+      where_query = f"WHERE {' AND '.join(filter_queries)}"
+
+    query = f"""
+      SELECT {outer_select} AS {value_column}, COUNT() AS {count_column}
+      FROM (SELECT {inner_select} AS {inner_val} FROM t {where_query})
+      GROUP BY {value_column}
+      ORDER BY {sort_by} {sort_order}
+      {limit_query}
+    """
+    df = self._query_df(query)
+    counts = list(df.itertuples(index=False, name=None))
+    if is_temporal(leaf.dtype):
+      # Replace any NaT with None and pd.Timestamp to native datetime objects.
+      counts = [(None if pd.isnull(val) else val.to_pydatetime(), count) for val, count in counts]
+    return SelectGroupsResult(too_many_distinct=False, counts=counts, bins=named_bins)
+
+  def _topk_udf_to_sort_by(
+    self,
+    udf_columns: list[Column],
+    sort_by: list[PathTuple],
+    limit: Optional[int],
+    sort_order: Optional[SortOrder],
+  ) -> Optional[Column]:
+    if (sort_order != SortOrder.DESC) or (not limit) or (not sort_by):
+      return None
+    if len(sort_by) < 1:
+      return None
+    primary_sort_by = sort_by[0]
+    udf_cols_to_sort_by = [
+      udf_col for udf_col in udf_columns if udf_col.alias == primary_sort_by[0] or
+      _path_contains(_col_destination_path(udf_col), primary_sort_by)
+    ]
+    if not udf_cols_to_sort_by:
+      return None
+    udf_col = udf_cols_to_sort_by[0]
+    if udf_col.signal_udf and not isinstance(udf_col.signal_udf, VectorSignal):
+      return None
+    return udf_col
+
+  def _normalize_columns(self, columns: Optional[Sequence[ColumnId]], schema: Schema,
+                         combine_columns: bool) -> list[Column]:
+    """Normalizes the columns to a list of `Column` objects."""
+    cols = [column_from_identifier(col) for col in columns or []]
+    star_in_cols = any(col.path == (PATH_WILDCARD,) for col in cols)
+    if not cols or star_in_cols:
+      # Select all columns.
+      cols.extend([Column((name,)) for name in schema.fields.keys() if name != ROWID])
+
+      if not combine_columns:
+        # Select all the signal top-level fields.
+        for path, field in schema.all_fields:
+          if field.signal:
+            cols.append(Column(path))
+
+      if star_in_cols:
+        cols = [col for col in cols if col.path != (PATH_WILDCARD,)]
+    return cols
+
+  def _merge_sorts(self, search_udfs: list[DuckDBSearchUDF], sort_by: Optional[Sequence[Path]],
+                   sort_order: Optional[SortOrder]) -> list[SortResult]:
+    # True when the user has explicitly sorted by the alias of a search UDF (e.g. in ASC order).
+    is_explicit_search_sort = False
+    for sort_by_path in sort_by or []:
+      for search_udf in search_udfs:
+        if column_paths_match(sort_by_path, search_udf.output_path):
+          is_explicit_search_sort = True
+          break
+
+    sort_results: list[SortResult] = []
+    if sort_by and not is_explicit_search_sort:
+      if not sort_order:
+        raise ValueError('`sort_order` is required when `sort_by` is specified.')
+      # If the user has explicitly set a sort by, and it's not a search UDF alias, override.
+      sort_results = [
+        SortResult(path=normalize_path(sort_by), order=sort_order) for sort_by in sort_by if sort_by
+      ]
+    else:
+      search_udfs_with_sort = [search_udf for search_udf in search_udfs if search_udf.sort]
+      if search_udfs_with_sort:
+        # Override the sort by the last search sort order when the user hasn't provided an
+        # explicit sort order.
+        last_search_udf = search_udfs_with_sort[-1]
+        assert last_search_udf.sort, 'Expected search UDFs with sort to have a sort.'
+        udf_sort_path, udf_sort_order = last_search_udf.sort
+        sort_results = [
+          SortResult(
+            path=udf_sort_path,
+            order=sort_order or udf_sort_order,
+            search_index=len(search_udfs_with_sort) - 1)
+        ]
+
+    return sort_results
+
+  @override
+  def select_rows(self,
+                  columns: Optional[Sequence[ColumnId]] = None,
+                  searches: Optional[Sequence[Search]] = None,
+                  filters: Optional[Sequence[FilterLike]] = None,
+                  sort_by: Optional[Sequence[Path]] = None,
+                  sort_order: Optional[SortOrder] = SortOrder.DESC,
+                  limit: Optional[int] = None,
+                  offset: Optional[int] = 0,
+                  task_step_id: Optional[TaskStepId] = None,
+                  resolve_span: bool = False,
+                  combine_columns: bool = False,
+                  user: Optional[UserInfo] = None) -> SelectRowsResult:
+    manifest = self.manifest()
+    cols = self._normalize_columns(columns, manifest.data_schema, combine_columns)
+    offset = offset or 0
+    schema = manifest.data_schema
+
+    if combine_columns:
+      schema = self.select_rows_schema(
+        columns, sort_by, sort_order, searches, combine_columns=True).data_schema
+
+    self._validate_columns(cols, manifest.data_schema, schema)
+    self._normalize_searches(searches, manifest)
+    search_udfs = self._search_udfs(searches, manifest)
+    cols.extend([search_udf.udf for search_udf in search_udfs])
+    udf_columns = [col for col in cols if col.signal_udf]
+
+    temp_rowid_selected = False
+    for col in cols:
+      if col.path == (ROWID,):
+        temp_rowid_selected = False
+        break
+      if isinstance(col.signal_udf, VectorSignal):
+        temp_rowid_selected = True
+    if temp_rowid_selected:
+      cols.append(Column(ROWID))
+
+    # Set extra information on any concept signals.
+    for udf_col in udf_columns:
+      if isinstance(udf_col.signal_udf, (ConceptSignal, ConceptLabelsSignal)):
+        # Concept are access controlled so we tell it about the user.
+        udf_col.signal_udf.set_user(user)
+
+    # Decide on the exact sorting order.
+    sort_results = self._merge_sorts(search_udfs, sort_by, sort_order)
+    sort_by = cast(list[PathTuple],
+                   [(sort.alias,) if sort.alias else sort.path for sort in sort_results])
+    # Choose the first sort order as we only support a single sort order for now.
+    sort_order = sort_results[0].order if sort_results else None
+
+    col_aliases: dict[str, PathTuple] = {col.alias: col.path for col in cols if col.alias}
+    udf_aliases: dict[str, PathTuple] = {
+      col.alias: col.path for col in cols if col.signal_udf and col.alias
+    }
+    path_to_udf_col_name: dict[PathTuple, str] = {}
+    for col in cols:
+      if col.signal_udf:
+        alias = col.alias or _unique_alias(col)
+        dest_path = _col_destination_path(col)
+        path_to_udf_col_name[dest_path] = alias
+
+    # Filtering and searching.
+    where_query = ''
+    filters, udf_filters = self._normalize_filters(filters, col_aliases, udf_aliases, manifest)
+    filter_queries = self._create_where(manifest, filters, searches)
+    if filter_queries:
+      where_query = f"WHERE {' AND '.join(filter_queries)}"
+
+    total_num_rows = manifest.num_items
+    con = self.con.cursor()
+
+    topk_udf_col = self._topk_udf_to_sort_by(udf_columns, sort_by, limit, sort_order)
+    if topk_udf_col:
+      path_keys: Optional[list[PathKey]] = None
+      if where_query:
+        # If there are filters, we need to send rowids to the top k query.
+        df = con.execute(f'SELECT {ROWID} FROM t {where_query}').df()
+        total_num_rows = len(df)
+        # Convert rowids to path keys.
+        path_keys = [(rowid,) for rowid in df[ROWID]]
+
+      if path_keys is not None and len(path_keys) == 0:
+        where_query = 'WHERE false'
+      else:
+        topk_signal = cast(VectorSignal, topk_udf_col.signal_udf)
+        # The input is an embedding.
+        vector_index = self._get_vector_db_index(topk_signal.embedding, topk_udf_col.path)
+        k = (limit or 0) + offset
+        path_id = f'{self.namespace}/{self.dataset_name}:{topk_udf_col.path}'
+        with DebugTimer(f'Computing topk on {path_id} with embedding "{topk_signal.embedding}" '
+                        f'and vector store "{vector_index._vector_store.name}"'):
+          topk = topk_signal.vector_compute_topk(k, vector_index, path_keys)
+        topk_rowids = list(dict.fromkeys([cast(str, rowid) for (rowid, *_), _ in topk]))
+        # Update the offset to account for the number of unique rowids.
+        offset = len(dict.fromkeys([cast(str, rowid) for (rowid, *_), _ in topk[:offset]]))
+
+        # Ignore all the other filters and filter DuckDB results only by the top k rowids.
+        rowid_filter = Filter(path=(ROWID,), op='in', value=topk_rowids)
+        filter_query = self._create_where(manifest, [rowid_filter])[0]
+        where_query = f'WHERE {filter_query}'
+
+    # Map a final column name to a list of temporary namespaced column names that need to be merged.
+    columns_to_merge: dict[str, dict[str, Column]] = {}
+    temp_column_to_offset_column: dict[str, tuple[str, Field]] = {}
+    select_queries: list[str] = []
+
+    for column in cols:
+      path = column.path
+      # If the signal is vector-based, we don't need to select the actual data, just the rowids
+      # plus an arbitrarily nested array of `None`s`.
+      empty = bool(column.signal_udf and schema.get_field(path).dtype == DataType.EMBEDDING)
+
+      select_sqls: list[str] = []
+      final_col_name = column.alias or _unique_alias(column)
+      if final_col_name not in columns_to_merge:
+        columns_to_merge[final_col_name] = {}
+
+      duckdb_paths = self._column_to_duckdb_paths(column, schema, combine_columns)
+      span_from = self._get_span_from(path, manifest) if resolve_span or column.signal_udf else None
+
+      for parquet_id, duckdb_path in duckdb_paths:
+        sql = _select_sql(
+          duckdb_path, flatten=False, unnest=False, empty=empty, span_from=span_from)
+        temp_column_name = (
+          final_col_name if len(duckdb_paths) == 1 else f'{final_col_name}/{parquet_id}')
+        select_sqls.append(f'{sql} AS {_escape_string_literal(temp_column_name)}')
+        columns_to_merge[final_col_name][temp_column_name] = column
+
+        if column.signal_udf and span_from and _schema_has_spans(column.signal_udf.fields()):
+          sql = _select_sql(duckdb_path, flatten=False, unnest=False, empty=empty, span_from=None)
+          temp_offset_column_name = f'{temp_column_name}/offset'
+          temp_offset_column_name = temp_offset_column_name.replace("'", "\\'")
+          select_sqls.append(f'{sql} AS {_escape_string_literal(temp_offset_column_name)}')
+          temp_column_to_offset_column[temp_column_name] = (temp_offset_column_name,
+                                                            column.signal_udf.fields())
+
+      # `select_sqls` can be empty if this column points to a path that will be created by a UDF.
+      if select_sqls:
+        select_queries.append(', '.join(select_sqls))
+
+    sort_sql_before_udf: list[str] = []
+    sort_sql_after_udf: list[str] = []
+
+    for path in sort_by:
+      # We only allow sorting by nodes with a value.
+      first_subpath = str(path[0])
+      rest_of_path = path[1:]
+      signal_alias = '.'.join(map(str, path))
+
+      udf_path = _path_to_udf_duckdb_path(path, path_to_udf_col_name)
+      if not udf_path:
+        # Re-route the path if it starts with an alias by pointing it to the actual path.
+        if first_subpath in col_aliases:
+          path = (*col_aliases[first_subpath], *rest_of_path)
+        self._validate_sort_path(path, schema)
+        path = self._leaf_path_to_duckdb_path(path, schema)
+      else:
+        path = udf_path
+
+      sort_sql = _select_sql(path, flatten=True, unnest=False)
+      has_repeated_field = any(subpath == PATH_WILDCARD for subpath in path)
+      if has_repeated_field:
+        sort_sql = (f'list_min({sort_sql})'
+                    if sort_order == SortOrder.ASC else f'list_max({sort_sql})')
+
+      # Separate sort columns into two groups: those that need to be sorted before and after UDFs.
+      if udf_path:
+        sort_sql_after_udf.append(sort_sql)
+      else:
+        sort_sql_before_udf.append(sort_sql)
+
+    order_query = ''
+    if sort_sql_before_udf:
+      order_query = (f'ORDER BY {", ".join(sort_sql_before_udf)} '
+                     f'{cast(SortOrder, sort_order).value}')
+
+    limit_query = ''
+    if limit:
+      if topk_udf_col:
+        limit_query = f'LIMIT {limit + offset}'
+      elif sort_sql_after_udf:
+        limit_query = ''
+      else:
+        limit_query = f'LIMIT {limit} OFFSET {offset}'
+
+    if not topk_udf_col and where_query:
+      total_num_rows = cast(tuple,
+                            con.execute(f'SELECT COUNT(*) FROM t {where_query}').fetchone())[0]
+
+    # Fetch the data from DuckDB.
+    df = con.execute(f"""
+      SELECT {', '.join(select_queries)} FROM t
+      {where_query}
+      {order_query}
+      {limit_query}
+    """).df()
+    df = _replace_nan_with_none(df)
+
+    # Run UDFs on the transformed columns.
+    for udf_col in udf_columns:
+      signal = cast(Signal, udf_col.signal_udf)
+      signal_alias = udf_col.alias or _unique_alias(udf_col)
+      temp_signal_cols = columns_to_merge[signal_alias]
+      if len(temp_signal_cols) != 1:
+        raise ValueError(
+          f'Unable to compute signal {signal.name}. Signal UDFs only operate on leafs, but got '
+          f'{len(temp_signal_cols)} underlying columns that contain data related to {udf_col.path}.'
+        )
+      signal_column = list(temp_signal_cols.keys())[0]
+      input = df[signal_column]
+
+      path_id = f'{self.namespace}/{self.dataset_name}:{udf_col.path}'
+      with DebugTimer(f'Computing signal "{signal.name}" on {path_id}'):
+        signal.setup()
+
+        step_description = f'Computing {signal.key()} on {path_id}'
+
+        if isinstance(signal, VectorSignal):
+          embedding_signal = signal
+          vector_store = self._get_vector_db_index(embedding_signal.embedding, udf_col.path)
+          flat_keys = list(flatten_keys(df[ROWID], input))
+          signal_out = sparse_to_dense_compute(
+            iter(flat_keys), lambda keys: embedding_signal.vector_compute(keys, vector_store))
+          # Add progress.
+          if task_step_id is not None:
+            signal_out = progress(
+              signal_out,
+              task_step_id=task_step_id,
+              estimated_len=len(flat_keys),
+              step_description=step_description)
+          df[signal_column] = deep_unflatten(signal_out, input)
+        else:
+          num_rich_data = count_primitives(input)
+          flat_input = cast(Iterator[Optional[RichData]], deep_flatten(input))
+          signal_out = sparse_to_dense_compute(
+            flat_input, lambda x: signal.compute(cast(Iterable[RichData], x)))
+          # Add progress.
+          if task_step_id is not None:
+            signal_out = progress(
+              signal_out,
+              task_step_id=task_step_id,
+              estimated_len=num_rich_data,
+              step_description=step_description)
+          signal_out_list = list(signal_out)
+          if signal_column in temp_column_to_offset_column:
+            offset_column_name, field = temp_column_to_offset_column[signal_column]
+            nested_spans: Iterable[Item] = df[offset_column_name]
+            flat_spans = deep_flatten(nested_spans)
+            for span, item in zip(flat_spans, signal_out_list):
+              _offset_any_span(cast(int, span[VALUE_KEY][TEXT_SPAN_START_FEATURE]), item, field)
+
+          if len(signal_out_list) != num_rich_data:
+            raise ValueError(
+              f'The signal generated {len(signal_out_list)} values but the input data had '
+              f"{num_rich_data} values. This means the signal either didn't generate a "
+              '"None" for a sparse output, or generated too many items.')
+
+          df[signal_column] = deep_unflatten(signal_out_list, input)
+
+        signal.teardown()
+
+    if not df.empty and (udf_filters or sort_sql_after_udf):
+      # Re-upload the udf outputs to duckdb so we can filter/sort on them.
+      rel = con.from_df(df)
+
+      if udf_filters:
+        udf_filter_queries = self._create_where(manifest, udf_filters)
+        if udf_filter_queries:
+          rel = rel.filter(' AND '.join(udf_filter_queries))
+          total_num_rows = cast(tuple, rel.count('*').fetchone())[0]
+
+      if sort_sql_after_udf:
+        if not sort_order:
+          raise ValueError('`sort_order` is required when `sort_by` is specified.')
+        rel = rel.order(f'{", ".join(sort_sql_after_udf)} {sort_order.value}')
+
+      if limit:
+        rel = rel.limit(limit, offset)
+
+      df = _replace_nan_with_none(rel.df())
+
+    if temp_rowid_selected:
+      del df[ROWID]
+      del columns_to_merge[ROWID]
+
+    if combine_columns:
+      all_columns: dict[str, Column] = {}
+      for col_dict in columns_to_merge.values():
+        all_columns.update(col_dict)
+      columns_to_merge = {'*': all_columns}
+
+    for offset_column, _ in temp_column_to_offset_column.values():
+      del df[offset_column]
+
+    for final_col_name, temp_columns in columns_to_merge.items():
+      for temp_col_name, column in temp_columns.items():
+        if combine_columns:
+          dest_path = _col_destination_path(column)
+          spec = _split_path_into_subpaths_of_lists(dest_path)
+          df[temp_col_name] = wrap_in_dicts(df[temp_col_name], spec)
+
+        # If the temp col name is the same as the final name, we can skip merging. This happens when
+        # we select a source leaf column.
+        if temp_col_name == final_col_name:
+          continue
+
+        if final_col_name not in df:
+          df[final_col_name] = df[temp_col_name]
+        else:
+          df[final_col_name] = merge_series(df[final_col_name], df[temp_col_name])
+        del df[temp_col_name]
+
+    con.close()
+
+    if combine_columns:
+      # Since we aliased every column to `*`, the object with have only '*' as the key. We need to
+      # elevate the all the columns under '*'.
+      df = pd.DataFrame.from_records(df['*'])
+
+    return SelectRowsResult(df, total_num_rows)
+
+  @override
+  def select_rows_schema(self,
+                         columns: Optional[Sequence[ColumnId]] = None,
+                         sort_by: Optional[Sequence[Path]] = None,
+                         sort_order: Optional[SortOrder] = None,
+                         searches: Optional[Sequence[Search]] = None,
+                         combine_columns: bool = False) -> SelectRowsSchemaResult:
+    """Returns the schema of the result of `select_rows` above with the same arguments."""
+    if not combine_columns:
+      raise NotImplementedError(
+        'select_rows_schema with combine_columns=False is not yet supported.')
+    manifest = self.manifest()
+    cols = self._normalize_columns(columns, manifest.data_schema, combine_columns)
+
+    self._normalize_searches(searches, manifest)
+    search_udfs = self._search_udfs(searches, manifest)
+    cols.extend([search_udf.udf for search_udf in search_udfs])
+
+    udfs: list[SelectRowsSchemaUDF] = []
+    col_schemas: list[Schema] = []
+    for col in cols:
+      dest_path = _col_destination_path(col)
+      if col.signal_udf:
+        udfs.append(SelectRowsSchemaUDF(path=dest_path, alias=col.alias))
+        field = col.signal_udf.fields()
+        field.signal = col.signal_udf.dict()
+      elif manifest.data_schema.has_field(dest_path):
+        field = manifest.data_schema.get_field(dest_path)
+      else:
+        # This column might refer to an output of a udf. We postpone validation to later.
+        continue
+      col_schemas.append(_make_schema_from_path(dest_path, field))
+
+    sort_results = self._merge_sorts(search_udfs, sort_by, sort_order)
+
+    search_results = [
+      SearchResultInfo(search_path=search_udf.search_path, result_path=search_udf.output_path)
+      for search_udf in search_udfs
+    ]
+
+    new_schema = merge_schemas(col_schemas)
+
+    # Now that we have the new schema, we can validate all the column selections.
+    self._validate_columns(cols, manifest.data_schema, new_schema)
+
+    return SelectRowsSchemaResult(
+      data_schema=new_schema, udfs=udfs, search_results=search_results, sorts=sort_results or None)
+
+  @override
+  def media(self, item_id: str, leaf_path: Path) -> MediaResult:
+    raise NotImplementedError('Media is not yet supported for the DuckDB implementation.')
+
+  def _get_span_from(self, path: PathTuple, manifest: DatasetManifest) -> Optional[PathTuple]:
+    leafs = manifest.data_schema.leafs
+    # Remove the value key so we can check the dtype from leafs.
+    span_path = path[:-1] if path[-1] == VALUE_KEY else path
+    is_span = (span_path in leafs and leafs[span_path].dtype == DataType.STRING_SPAN)
+    return _derived_from_path(path, manifest.data_schema) if is_span else None
+
+  def _leaf_path_to_duckdb_path(self, leaf_path: PathTuple, schema: Schema) -> PathTuple:
+    ((_, duckdb_path),) = self._column_to_duckdb_paths(
+      Column(leaf_path), schema, combine_columns=False, select_leaf=True)
+    return duckdb_path
+
+  def _column_to_duckdb_paths(self,
+                              column: Column,
+                              schema: Schema,
+                              combine_columns: bool,
+                              select_leaf: bool = False) -> list[tuple[str, PathTuple]]:
+    path = column.path
+    parquet_manifests: list[Union[SourceManifest, SignalManifest]] = [
+      self._source_manifest, *self._signal_manifests
+    ]
+    duckdb_paths: list[tuple[str, PathTuple]] = []
+    source_has_path = False
+
+    select_leaf = select_leaf or column.signal_udf is not None
+
+    if path == (ROWID,):
+      return [('source', path)]
+
+    for m in parquet_manifests:
+      if not m.files:
+        continue
+      # Skip this parquet file if it doesn't contain the path.
+      if not schema_contains_path(m.data_schema, path):
+        continue
+
+      if isinstance(m, SourceManifest):
+        source_has_path = True
+
+      if isinstance(m, SignalManifest) and source_has_path and not combine_columns:
+        # Skip this signal if the source already has the path and we are not combining columns.
+        continue
+
+      # Skip this parquet file if the path doesn't have a dtype.
+      if select_leaf and not m.data_schema.get_field(path).dtype:
+        continue
+
+      duckdb_path = path
+      parquet_id = 'source'
+
+      if isinstance(m, SignalManifest):
+        duckdb_path = (m.parquet_id, *path[1:])
+        parquet_id = m.parquet_id
+
+      duckdb_paths.append((parquet_id, duckdb_path))
+
+    if not duckdb_paths:
+      # This path is probably a result of a udf. Make sure the result schema contains it.
+      if not schema.has_field(path):
+        raise ValueError(f'Invalid path "{path}": No manifest contains path. Valid paths: '
+                         f'{list(schema.leafs.keys())}')
+
+    return duckdb_paths
+
+  def _normalize_filters(self, filter_likes: Optional[Sequence[FilterLike]],
+                         col_aliases: dict[str, PathTuple], udf_aliases: dict[str, PathTuple],
+                         manifest: DatasetManifest) -> tuple[list[Filter], list[Filter]]:
+    """Normalize `FilterLike` to `Filter` and split into filters on source and filters on UDFs."""
+    filter_likes = filter_likes or []
+    filters: list[Filter] = []
+    udf_filters: list[Filter] = []
+
+    for filter in filter_likes:
+      # Normalize `FilterLike` to `Filter`.
+      if not isinstance(filter, Filter):
+        if len(filter) == 3:
+          path, op, value = filter  # type: ignore
+        elif len(filter) == 2:
+          path, op = filter  # type: ignore
+          value = None
+        else:
+          raise ValueError(f'Invalid filter: {filter}. Must be a tuple with 2 or 3 elements.')
+        filter = Filter(path=normalize_path(path), op=op, value=value)
+
+      if str(filter.path[0]) in udf_aliases:
+        udf_filters.append(filter)
+      else:
+        filters.append(filter)
+
+    self._validate_filters(filters, col_aliases, manifest)
+    return filters, udf_filters
+
+  def _normalize_searches(self, searches: Optional[Sequence[Search]],
+                          manifest: DatasetManifest) -> None:
+    """Validate searches."""
+    if not searches:
+      return
+
+    for search in searches:
+      search.path = normalize_path(search.path)
+      field = manifest.data_schema.get_field(search.path)
+      if field.dtype != DataType.STRING:
+        raise ValueError(f'Invalid search path: {search.path}. '
+                         f'Must be a string field, got dtype {field.dtype}')
+
+  def _search_udfs(self, searches: Optional[Sequence[Search]],
+                   manifest: DatasetManifest) -> list[DuckDBSearchUDF]:
+    searches = searches or []
+    """Create a UDF for each search for finding the location of the text with spans."""
+    search_udfs: list[DuckDBSearchUDF] = []
+    for search in searches:
+      search_path = normalize_path(search.path)
+      if search.type == 'keyword':
+        udf = Column(path=search_path, signal_udf=SubstringSignal(query=search.query))
+        search_udfs.append(
+          DuckDBSearchUDF(
+            udf=udf,
+            search_path=search_path,
+            output_path=(*_col_destination_path(udf), PATH_WILDCARD)))
+      elif search.type == 'semantic' or search.type == 'concept':
+        embedding = search.embedding
+        if not embedding:
+          raise ValueError(f'Please provide an embedding for semantic search. Got search: {search}')
+
+        try:
+          manifest.data_schema.get_field((*search_path, embedding))
+        except Exception as e:
+          raise ValueError(
+            f'Embedding {embedding} has not been computed. '
+            f'Please compute the embedding index before issuing a {search.type} query.') from e
+
+        search_signal: Optional[Signal] = None
+        if search.type == 'semantic':
+          search_signal = SemanticSimilaritySignal(query=search.query, embedding=search.embedding)
+        elif search.type == 'concept':
+          search_signal = ConceptSignal(
+            namespace=search.concept_namespace,
+            concept_name=search.concept_name,
+            embedding=search.embedding)
+
+          # Add the label UDF.
+          concept_labels_signal = ConceptLabelsSignal(
+            namespace=search.concept_namespace, concept_name=search.concept_name)
+          concept_labels_udf = Column(path=search_path, signal_udf=concept_labels_signal)
+          search_udfs.append(
+            DuckDBSearchUDF(
+              udf=concept_labels_udf,
+              search_path=search_path,
+              output_path=_col_destination_path(concept_labels_udf),
+              sort=None))
+
+        udf = Column(path=search_path, signal_udf=search_signal)
+
+        output_path = _col_destination_path(udf)
+        search_udfs.append(
+          DuckDBSearchUDF(
+            udf=udf,
+            search_path=search_path,
+            output_path=_col_destination_path(udf),
+            sort=((*output_path, PATH_WILDCARD, 'score'), SortOrder.DESC)))
+      else:
+        raise ValueError(f'Unknown search operator {search.type}.')
+
+    return search_udfs
+
+  def _create_where(self,
+                    manifest: DatasetManifest,
+                    filters: list[Filter],
+                    searches: Optional[Sequence[Search]] = []) -> list[str]:
+    if not filters and not searches:
+      return []
+    searches = searches or []
+    sql_filter_queries: list[str] = []
+
+    # Add search where queries.
+    for search in searches:
+      duckdb_path = self._leaf_path_to_duckdb_path(
+        normalize_path(search.path), manifest.data_schema)
+      select_str = _select_sql(duckdb_path, flatten=False, unnest=False)
+      if search.type == 'keyword':
+        sql_op = 'ILIKE'
+        query_val = _escape_like_value(search.query)
+      elif search.type == 'semantic' or search.type == 'concept':
+        # Semantic search and concepts don't yet filter.
+        continue
+      else:
+        raise ValueError(f'Unknown search operator {search.type}.')
+
+      filter_query = f'{select_str} {sql_op} {query_val}'
+
+      sql_filter_queries.append(filter_query)
+
+    # Add filter where queries.
+    for f in filters:
+      duckdb_path = self._leaf_path_to_duckdb_path(f.path, manifest.data_schema)
+      select_str = _select_sql(
+        duckdb_path, flatten=True, unnest=False, span_from=self._get_span_from(f.path, manifest))
+      is_array = any(subpath == PATH_WILDCARD for subpath in f.path)
+
+      nan_filter = ''
+      field = manifest.data_schema.get_field(f.path)
+      filter_nans = field.dtype and is_float(field.dtype)
+
+      if f.op in BINARY_OPS:
+        sql_op = BINARY_OP_TO_SQL[cast(BinaryOp, f.op)]
+        filter_val = cast(FeatureValue, f.value)
+        if isinstance(filter_val, str):
+          filter_val = _escape_string_literal(filter_val)
+        elif isinstance(filter_val, bytes):
+          filter_val = _bytes_to_blob_literal(filter_val)
+        else:
+          filter_val = str(filter_val)
+        if is_array:
+          nan_filter = 'NOT isnan(x) AND' if filter_nans else ''
+          filter_query = (f'len(list_filter({select_str}, '
+                          f'x -> {nan_filter} x {sql_op} {filter_val})) > 0')
+        else:
+          nan_filter = f'NOT isnan({select_str}) AND' if filter_nans else ''
+          filter_query = f'{nan_filter} {select_str} {sql_op} {filter_val}'
+      elif f.op in UNARY_OPS:
+        if f.op == 'exists':
+          filter_query = f'len({select_str}) > 0' if is_array else f'{select_str} IS NOT NULL'
+        else:
+          raise ValueError(f'Unary op: {f.op} is not yet supported')
+      elif f.op in LIST_OPS:
+        if f.op == 'in':
+          filter_list_val = cast(FeatureListValue, f.value)
+          if not isinstance(filter_list_val, list):
+            raise ValueError('filter with array value can only use the IN comparison')
+          wrapped_filter_val = [f"'{part}'" for part in filter_list_val]
+          filter_val = f'({", ".join(wrapped_filter_val)})'
+          filter_query = f'{select_str} IN {filter_val}'
+        else:
+          raise ValueError(f'List op: {f.op} is not yet supported')
+      else:
+        raise ValueError(f'Invalid filter op: {f.op}')
+      sql_filter_queries.append(filter_query)
+    return sql_filter_queries
+
+  def _execute(self, query: str) -> duckdb.DuckDBPyConnection:
+    """Execute a query in duckdb."""
+    # FastAPI is multi-threaded so we have to create a thread-specific connection cursor to allow
+    # these queries to be thread-safe.
+    local_con = self.con.cursor()
+    if not env('DEBUG', False):
+      return local_con.execute(query)
+
+    # Debug mode.
+    log('Executing:')
+    log(query)
+    with DebugTimer('Query'):
+      return local_con.execute(query)
+
+  def _query(self, query: str) -> list[tuple]:
+    result = self._execute(query)
+    rows = result.fetchall()
+    result.close()
+    return rows
+
+  def _query_df(self, query: str) -> pd.DataFrame:
+    """Execute a query that returns a data frame."""
+    result = self._execute(query)
+    df = _replace_nan_with_none(result.df())
+    result.close()
+    return df
+
+  def _path_to_col(self, path: Path, quote_each_part: bool = True) -> str:
+    """Convert a path to a column name."""
+    if isinstance(path, str):
+      path = (path,)
+    return '.'.join([
+      f'{_escape_col_name(path_comp)}' if quote_each_part else str(path_comp) for path_comp in path
+    ])
+
+  def _get_selection(self, columns: Optional[Sequence[ColumnId]] = None) -> str:
+    """Get the selection clause for download a dataset."""
+    manifest = self.manifest()
+    cols = self._normalize_columns(columns, manifest.data_schema, combine_columns=False)
+    schema = manifest.data_schema
+    self._validate_columns(cols, manifest.data_schema, schema)
+
+    select_queries: list[str] = []
+    for column in cols:
+      col_name = column.alias or _unique_alias(column)
+      duckdb_paths = self._column_to_duckdb_paths(column, schema, combine_columns=False)
+      if not duckdb_paths:
+        raise ValueError(f'Cannot download path {column.path} which does not exist in the dataset.')
+      if len(duckdb_paths) > 1:
+        raise ValueError(
+          f'Cannot download path {column.path} which spans multiple parquet files: {duckdb_paths}')
+      _, duckdb_path = duckdb_paths[0]
+      sql = _select_sql(duckdb_path, flatten=False, unnest=False)
+      select_queries.append(f'{sql} AS {_escape_string_literal(col_name)}')
+    return ', '.join(select_queries)
+
+  @override
+  def to_json(self,
+              filepath: Union[str, pathlib.Path],
+              jsonl: bool = True,
+              columns: Optional[Sequence[ColumnId]] = None) -> None:
+    selection = self._get_selection(columns)
+    self._execute(f"COPY (SELECT {selection} FROM t) TO '{filepath}' "
+                  f"(FORMAT JSON, ARRAY {'FALSE' if jsonl else 'TRUE'})")
+    log(f'Dataset exported to {filepath}')
+
+  @override
+  def to_pandas(self, columns: Optional[Sequence[ColumnId]] = None) -> pd.DataFrame:
+    selection = self._get_selection(columns)
+    return self._query_df(f'SELECT {selection} FROM t')
+
+  @override
+  def to_csv(self,
+             filepath: Union[str, pathlib.Path],
+             columns: Optional[Sequence[ColumnId]] = None) -> None:
+    selection = self._get_selection(columns)
+    self._execute(f"COPY (SELECT {selection} FROM t) TO '{filepath}' (FORMAT CSV, HEADER)")
+    log(f'Dataset exported to {filepath}')
+
+  @override
+  def to_parquet(self,
+                 filepath: Union[str, pathlib.Path],
+                 columns: Optional[Sequence[ColumnId]] = None) -> None:
+    selection = self._get_selection(columns)
+    self._execute(f"COPY (SELECT {selection} FROM t) TO '{filepath}' (FORMAT PARQUET)")
+    log(f'Dataset exported to {filepath}')
+
+
+def _escape_string_literal(string: str) -> str:
+  string = string.replace("'", "''")
+  return f"'{string}'"
+
+
+def _escape_col_name(col_name: str) -> str:
+  col_name = col_name.replace('"', '""')
+  return f'"{col_name}"'
+
+
+def _escape_like_value(value: str) -> str:
+  value = value.replace('%', '\\%').replace('_', '\\_')
+  return f"'%{value}%' ESCAPE '\\'"
+
+
+def _inner_select(sub_paths: list[PathTuple],
+                  inner_var: Optional[str] = None,
+                  empty: bool = False,
+                  span_from: Optional[PathTuple] = None) -> str:
+  """Recursively generate the inner select statement for a list of sub paths."""
+  current_sub_path = sub_paths[0]
+  lambda_var = inner_var + 'x' if inner_var else 'x'
+  if not inner_var:
+    lambda_var = 'x'
+    inner_var = _escape_col_name(current_sub_path[0])
+    current_sub_path = current_sub_path[1:]
+  # Select the path inside structs. E.g. x['a']['b']['c'] given current_sub_path = [a, b, c].
+  path_key = inner_var + ''.join([f'[{_escape_string_literal(p)}]' for p in current_sub_path])
+  if len(sub_paths) == 1:
+    if span_from:
+      derived_col = _select_sql(span_from, flatten=False, unnest=False)
+      path_key = (f'{derived_col}[{path_key}.{VALUE_KEY}.{TEXT_SPAN_START_FEATURE}+1:'
+                  f'{path_key}.{VALUE_KEY}.{TEXT_SPAN_END_FEATURE}]')
+    return 'NULL' if empty else path_key
+  return (f'list_transform({path_key}, {lambda_var} -> '
+          f'{_inner_select(sub_paths[1:], lambda_var, empty, span_from)})')
+
+
+def _split_path_into_subpaths_of_lists(leaf_path: PathTuple) -> list[PathTuple]:
+  """Split a path into a subpath of lists.
+
+  E.g. [a, b, c, *, d, *, *] gets splits [[a, b, c], [d], [], []].
+  """
+  sub_paths: list[PathTuple] = []
+  offset = 0
+  while offset <= len(leaf_path):
+    new_offset = leaf_path.index(PATH_WILDCARD,
+                                 offset) if PATH_WILDCARD in leaf_path[offset:] else len(leaf_path)
+    sub_path = leaf_path[offset:new_offset]
+    sub_paths.append(sub_path)
+    offset = new_offset + 1
+  return sub_paths
+
+
+def _select_sql(path: PathTuple,
+                flatten: bool,
+                unnest: bool,
+                empty: bool = False,
+                span_from: Optional[PathTuple] = None) -> str:
+  """Create a select column for a path.
+
+  Args:
+    path: A path to a feature. E.g. ['a', 'b', 'c'].
+    flatten: Whether to flatten the result.
+    unnest: Whether to unnest the result.
+    empty: Whether to return an empty list (used for embedding signals that don't need the data).
+    span_from: The path this span is derived from. If specified, the span will be resolved
+      to a substring of the original string.
+  """
+  sub_paths = _split_path_into_subpaths_of_lists(path)
+  selection = _inner_select(sub_paths, None, empty, span_from)
+  # We only flatten when the result of a nested list to avoid segfault.
+  is_result_nested_list = len(sub_paths) >= 3  # E.g. subPaths = [[a, b, c], *, *].
+  if flatten and is_result_nested_list:
+    selection = f'flatten({selection})'
+  # We only unnest when the result is a list. // E.g. subPaths = [[a, b, c], *].
+  is_result_a_list = len(sub_paths) >= 2
+  if unnest and is_result_a_list:
+    selection = f'unnest({selection})'
+  return selection
+
+
+def read_source_manifest(dataset_path: str) -> SourceManifest:
+  """Read the manifest file."""
+  with open_file(os.path.join(dataset_path, MANIFEST_FILENAME), 'r') as f:
+    return SourceManifest.parse_raw(f.read())
+
+
+def _signal_dir(enriched_path: PathTuple) -> str:
+  """Get the filename prefix for a signal parquet file."""
+  path_without_wildcards = (p for p in enriched_path if p != PATH_WILDCARD)
+  return os.path.join(*path_without_wildcards)
+
+
+def split_column_name(column: str, split_name: str) -> str:
+  """Get the name of a split column."""
+  return f'{column}.{split_name}'
+
+
+def split_parquet_prefix(column_name: str, splitter_name: str) -> str:
+  """Get the filename prefix for a split parquet file."""
+  return f'{column_name}.{splitter_name}'
+
+
+def _bytes_to_blob_literal(bytes: bytes) -> str:
+  """Convert bytes to a blob literal."""
+  escaped_hex = re.sub(r'(.{2})', r'\\x\1', bytes.hex())
+  return f"'{escaped_hex}'::BLOB"
+
+
+class SignalManifest(BaseModel):
+  """The manifest that describes a signal computation including schema and parquet files."""
+  # List of a parquet filepaths storing the data. The paths are relative to the manifest.
+  files: list[str]
+
+  # An identifier for this parquet table. Will be used as the view name in SQL.
+  parquet_id: str
+
+  data_schema: Schema
+  signal: Signal
+
+  # The column path that this signal is derived from.
+  enriched_path: PathTuple
+
+  # The name of the vector store. Present when the signal is an embedding.
+  vector_store: Optional[str] = None
+
+  @validator('signal', pre=True)
+  def parse_signal(cls, signal: dict) -> Signal:
+    """Parse a signal to its specific subclass instance."""
+    return resolve_signal(signal)
+
+
+def _merge_cells(dest_cell: Item, source_cell: Item) -> Item:
+  if source_cell is None or isinstance(source_cell, float) and math.isnan(source_cell):
+    # Nothing to merge here (missing value).
+    return dest_cell
+  if isinstance(dest_cell, dict):
+    if isinstance(source_cell, list):
+      raise ValueError(f'Failed to merge cells. Destination is a dict ({dest_cell!r}), '
+                       f'but source is a list ({source_cell!r}).')
+    if isinstance(source_cell, dict):
+      res = {**dest_cell}
+      for key, value in source_cell.items():
+        res[key] = (value if key not in dest_cell else _merge_cells(dest_cell[key], value))
+      return res
+    else:
+      return {VALUE_KEY: source_cell, **dest_cell}
+  elif isinstance(dest_cell, list):
+    if not isinstance(source_cell, list):
+      raise ValueError('Failed to merge cells. Destination is a list, but source is not.')
+    return [
+      _merge_cells(dest_subcell, source_subcell)
+      for dest_subcell, source_subcell in zip(dest_cell, source_cell)
+    ]
+  else:
+    # The destination is a primitive.
+    if isinstance(source_cell, list):
+      raise ValueError(f'Failed to merge cells. Destination is a primitive ({dest_cell!r}), '
+                       f'but source is a list ({source_cell!r}).')
+    if isinstance(source_cell, dict):
+      return {VALUE_KEY: dest_cell, **source_cell}
+    else:
+      # Primitives can be merged together if they are equal. This can happen if a user selects a
+      # column that is the child of another.
+      # NOTE: This can be removed if we fix https://github.com/lilacai/lilac/issues/166.
+      if source_cell != dest_cell:
+        raise ValueError(f'Cannot merge source "{source_cell!r}" into destination "{dest_cell!r}"')
+      return dest_cell
+
+
+def merge_series(destination: pd.Series, source: pd.Series) -> list[Item]:
+  """Merge two series of values recursively."""
+  return _merge_cells(destination.tolist(), source.tolist())
+
+
+def _unique_alias(column: Column) -> str:
+  """Get a unique alias for a selection column."""
+  if column.signal_udf:
+    return make_parquet_id(column.signal_udf, column.path)
+  return '.'.join(map(str, column.path))
+
+
+def _path_contains(parent_path: PathTuple, child_path: PathTuple) -> bool:
+  """Check if a path contains another path."""
+  if len(parent_path) > len(child_path):
+    return False
+  return all(parent_path[i] == child_path[i] for i in range(len(parent_path)))
+
+
+def _path_to_udf_duckdb_path(path: PathTuple,
+                             path_to_udf_col_name: dict[PathTuple, str]) -> Optional[PathTuple]:
+  first_subpath, *rest_of_path = path
+  for parent_path, udf_col_name in path_to_udf_col_name.items():
+    # If the user selected udf(document.*.text) as "udf" and wanted to sort by "udf.len", we need to
+    # sort by "udf.*.len" where the "*" came from the fact that the udf was applied to a list of
+    # "text" fields.
+    wildcards = [x for x in parent_path if x == PATH_WILDCARD]
+    if _path_contains(parent_path, path):
+      return (udf_col_name, *wildcards, *path[len(parent_path):])
+    elif first_subpath == udf_col_name:
+      return (udf_col_name, *wildcards, *rest_of_path)
+
+  return None
+
+
+def _col_destination_path(column: Column, is_computed_signal: Optional[bool] = False) -> PathTuple:
+  """Get the destination path where the output of this selection column will be stored."""
+  source_path = column.path
+
+  if not column.signal_udf:
+    return source_path
+
+  signal_key = column.signal_udf.key(is_computed_signal=is_computed_signal)
+  # If we are enriching a value we should store the signal data in the value's parent.
+  if source_path[-1] == VALUE_KEY:
+    dest_path = (*source_path[:-1], signal_key)
+  else:
+    dest_path = (*source_path, signal_key)
+
+  return dest_path
+
+
+def _root_column(manifest: SignalManifest) -> str:
+  """Returns the root column of a signal manifest."""
+  field_keys = list(manifest.data_schema.fields.keys())
+  if len(field_keys) > 2:
+    raise ValueError('Expected at most two fields in signal manifest, '
+                     f'the rowid and root this signal is enriching. Got {field_keys}.')
+  return next(filter(lambda field: field != ROWID, manifest.data_schema.fields.keys()))
+
+
+def _derived_from_path(path: PathTuple, schema: Schema) -> PathTuple:
+  # Find the closest parent of `path` that is a signal root.
+  for i in reversed(range(len(path))):
+    sub_path = path[:i]
+    if schema.get_field(sub_path).signal is not None:
+      # Skip the signal name at the end to get the source path that was enriched.
+      return sub_path[:-1]
+  raise ValueError('Cannot find the source path for the enriched path: {path}')
+
+
+def _make_schema_from_path(path: PathTuple, field: Field) -> Schema:
+  """Returns a schema that contains only the given path."""
+  for sub_path in reversed(path):
+    if sub_path == PATH_WILDCARD:
+      field = Field(repeated_field=field)
+    else:
+      field = Field(fields={sub_path: field})
+  if not field.fields:
+    raise ValueError(f'Invalid path: {path}. Must contain at least one field name.')
+  return Schema(fields=field.fields)
+
+
+def _replace_nan_with_none(df: pd.DataFrame) -> pd.DataFrame:
+  """DuckDB returns np.nan for missing field in string column, replace with None for correctness."""
+  # TODO(https://github.com/duckdb/duckdb/issues/4066): Remove this once duckdb fixes upstream.
+  for col in df.columns:
+    if is_object_dtype(df[col]):
+      df[col].replace(np.nan, None, inplace=True)
+  return df
+
+
+def _offset_any_span(offset: int, item: Item, schema: Field) -> None:
+  """Offsets any spans inplace by the given parent offset."""
+  if schema.dtype == DataType.STRING_SPAN:
+    item = cast(dict, item)
+    item[VALUE_KEY][TEXT_SPAN_START_FEATURE] += offset
+    item[VALUE_KEY][TEXT_SPAN_END_FEATURE] += offset
+  if schema.fields:
+    item = cast(dict, item)
+    for key, sub_schema in schema.fields.items():
+      _offset_any_span(offset, item[key], sub_schema)
+  if schema.repeated_field:
+    item = cast(list, item)
+    for sub_item in item:
+      _offset_any_span(offset, sub_item, schema.repeated_field)
+
+
+def _schema_has_spans(field: Field) -> bool:
+  if field.dtype and field.dtype == DataType.STRING_SPAN:
+    return True
+  if field.fields:
+    children_have_spans = any(_schema_has_spans(sub_field) for sub_field in field.fields.values())
+    if children_have_spans:
+      return True
+  if field.repeated_field:
+    return _schema_has_spans(field.repeated_field)
+  return False
+
+
+def _normalize_bins(bins: Optional[Union[Sequence[Bin], Sequence[float]]]) -> Optional[list[Bin]]:
+  if bins is None:
+    return None
+  if not isinstance(bins[0], (float, int)):
+    return cast(list[Bin], bins)
+  named_bins: list[Bin] = []
+  for i in range(len(bins) + 1):
+    start = cast(float, bins[i - 1]) if i > 0 else None
+    end = cast(float, bins[i]) if i < len(bins) else None
+    named_bins.append((str(i), start, end))
+  return named_bins
+
+
+def _auto_bins(stats: StatsResult, num_bins: int) -> list[Bin]:
+  min_val = cast(float, stats.min_val)
+  max_val = cast(float, stats.max_val)
+  bin_width = (max_val - min_val) / num_bins
+  bins: list[Bin] = []
+  for i in range(num_bins):
+    start = None if i == 0 else min_val + i * bin_width
+    end = None if i == num_bins - 1 else min_val + (i + 1) * bin_width
+    bins.append((str(i), start, end))
+  return bins
+
+
+def get_config_filepath(namespace: str, dataset_name: str) -> str:
+  """Gets the config yaml filepath."""
+  return os.path.join(get_dataset_output_dir(data_path(), namespace, dataset_name), CONFIG_FILENAME)

lilac/data/dataset_test_utils.py

@@ -0,0 +1,153 @@
+"""Tests utils of for dataset_test."""
+import os
+import pathlib
+from copy import deepcopy
+from datetime import datetime
+from typing import Optional, Type, cast
+
+import numpy as np
+from typing_extensions import Protocol
+
+from ..config import CONFIG_FILENAME, DatasetConfig
+from ..embeddings.vector_store import VectorDBIndex
+from ..schema import (
+  MANIFEST_FILENAME,
+  PARQUET_FILENAME_PREFIX,
+  ROWID,
+  VALUE_KEY,
+  DataType,
+  Field,
+  Item,
+  PathKey,
+  Schema,
+  SourceManifest,
+)
+from ..sources.source import Source
+from ..utils import get_dataset_output_dir, open_file, to_yaml
+from .dataset import Dataset, default_settings
+from .dataset_utils import is_primitive, write_items_to_parquet
+
+TEST_NAMESPACE = 'test_namespace'
+TEST_DATASET_NAME = 'test_dataset'
+
+
+def _infer_dtype(value: Item) -> DataType:
+  if isinstance(value, str):
+    return DataType.STRING
+  elif isinstance(value, bool):
+    return DataType.BOOLEAN
+  elif isinstance(value, bytes):
+    return DataType.BINARY
+  elif isinstance(value, float):
+    return DataType.FLOAT32
+  elif isinstance(value, int):
+    return DataType.INT32
+  elif isinstance(value, datetime):
+    return DataType.TIMESTAMP
+  else:
+    raise ValueError(f'Cannot infer dtype of primitive value: {value}')
+
+
+def _infer_field(item: Item) -> Field:
+  """Infer the schema from the items."""
+  if isinstance(item, dict):
+    fields: dict[str, Field] = {}
+    for k, v in item.items():
+      fields[k] = _infer_field(cast(Item, v))
+    dtype = None
+    if VALUE_KEY in fields:
+      dtype = fields[VALUE_KEY].dtype
+      del fields[VALUE_KEY]
+    return Field(fields=fields, dtype=dtype)
+  elif is_primitive(item):
+    return Field(dtype=_infer_dtype(item))
+  elif isinstance(item, list):
+    return Field(repeated_field=_infer_field(item[0]))
+  else:
+    raise ValueError(f'Cannot infer schema of item: {item}')
+
+
+def _infer_schema(items: list[Item]) -> Schema:
+  """Infer the schema from the items."""
+  schema = Schema(fields={})
+  for item in items:
+    field = _infer_field(item)
+    if not field.fields:
+      raise ValueError(f'Invalid schema of item. Expected an object, but got: {item}')
+    schema.fields = {**schema.fields, **field.fields}
+  return schema
+
+
+class TestDataMaker(Protocol):
+  """A function that creates a test dataset."""
+
+  def __call__(self, items: list[Item], schema: Optional[Schema] = None) -> Dataset:
+    """Create a test dataset."""
+    ...
+
+
+class TestSource(Source):
+  """Test source that does nothing."""
+  name = 'test_source'
+
+
+def make_dataset(dataset_cls: Type[Dataset],
+                 tmp_path: pathlib.Path,
+                 items: list[Item],
+                 schema: Optional[Schema] = None) -> Dataset:
+  """Create a test dataset."""
+  schema = schema or _infer_schema(items)
+  _write_items(tmp_path, TEST_DATASET_NAME, items, schema)
+  dataset = dataset_cls(TEST_NAMESPACE, TEST_DATASET_NAME)
+
+  config = DatasetConfig(
+    namespace=TEST_NAMESPACE,
+    name=TEST_DATASET_NAME,
+    source=TestSource(),
+    settings=default_settings(dataset))
+  config_filepath = os.path.join(
+    get_dataset_output_dir(str(tmp_path), TEST_NAMESPACE, TEST_DATASET_NAME), CONFIG_FILENAME)
+  with open_file(config_filepath, 'w') as f:
+    f.write(to_yaml(config.dict(exclude_defaults=True, exclude_none=True, exclude_unset=True)))
+
+  return dataset
+
+
+def _write_items(tmpdir: pathlib.Path, dataset_name: str, items: list[Item],
+                 schema: Schema) -> None:
+  """Write the items JSON to the dataset format: manifest.json and parquet files."""
+  source_dir = get_dataset_output_dir(str(tmpdir), TEST_NAMESPACE, dataset_name)
+  os.makedirs(source_dir)
+
+  # Add rowids to the items.
+  items = [deepcopy(item) for item in items]
+  for i, item in enumerate(items):
+    item[ROWID] = str(i + 1)
+
+  simple_parquet_files, _ = write_items_to_parquet(
+    items, source_dir, schema, filename_prefix=PARQUET_FILENAME_PREFIX, shard_index=0, num_shards=1)
+  manifest = SourceManifest(files=[simple_parquet_files], data_schema=schema)
+  with open_file(os.path.join(source_dir, MANIFEST_FILENAME), 'w') as f:
+    f.write(manifest.json(indent=2, exclude_none=True))
+
+
+def enriched_item(value: Optional[Item] = None, metadata: dict[str, Item] = {}) -> Item:
+  """Wrap a value in a dict with the value key."""
+  return {VALUE_KEY: value, **metadata}
+
+
+def make_vector_index(vector_store: str, vector_dict: dict[PathKey,
+                                                           list[list[float]]]) -> VectorDBIndex:
+  """Make a vector index from a dictionary of vector keys to vectors."""
+  embeddings: list[np.ndarray] = []
+  spans: list[tuple[PathKey, list[tuple[int, int]]]] = []
+  for path_key, vectors in vector_dict.items():
+    vector_spans: list[tuple[int, int]] = []
+    for i, vector in enumerate(vectors):
+      embeddings.append(np.array(vector))
+      vector_spans.append((0, 0))
+    spans.append((path_key, vector_spans))
+
+  vector_index = VectorDBIndex(vector_store)
+  vector_index.add(spans, np.array(embeddings))
+  return vector_index

lilac/data/dataset_utils.py

@@ -0,0 +1,313 @@
+"""Utilities for working with datasets."""
+
+import gc
+import json
+import math
+import os
+import pprint
+import secrets
+from collections.abc import Iterable
+from typing import Any, Callable, Iterator, Optional, Sequence, TypeVar, Union, cast
+
+import numpy as np
+import pyarrow as pa
+
+from ..batch_utils import deep_flatten
+from ..embeddings.vector_store import VectorDBIndex
+from ..env import env
+from ..parquet_writer import ParquetWriter
+from ..schema import (
+  EMBEDDING_KEY,
+  PATH_WILDCARD,
+  ROWID,
+  TEXT_SPAN_END_FEATURE,
+  TEXT_SPAN_START_FEATURE,
+  VALUE_KEY,
+  DataType,
+  Field,
+  Item,
+  PathKey,
+  PathTuple,
+  Schema,
+  VectorKey,
+  field,
+  schema,
+  schema_to_arrow_schema,
+)
+from ..signal import Signal
+from ..utils import is_primitive, log, open_file
+
+
+def _replace_embeddings_with_none(input: Union[Item, Item]) -> Union[Item, Item]:
+  if isinstance(input, np.ndarray):
+    return None
+  if isinstance(input, dict):
+    return {k: _replace_embeddings_with_none(v) for k, v in input.items()}
+  if isinstance(input, list):
+    return [_replace_embeddings_with_none(v) for v in input]
+
+  return input
+
+
+def replace_embeddings_with_none(input: Union[Item, Item]) -> Item:
+  """Replaces all embeddings with None."""
+  return cast(Item, _replace_embeddings_with_none(input))
+
+
+def count_primitives(input: Union[Iterable, Iterator]) -> int:
+  """Iterate through each element of the input, flattening each one, computing a count.
+
+  Sum the final set of counts. This is the important iterable not to exhaust.
+  """
+  return sum((len(list(deep_flatten(i))) for i in input))
+
+
+def _wrap_value_in_dict(input: Union[object, dict], props: PathTuple) -> Union[object, dict]:
+  # If the signal produced no value, or nan, we should return None so the parquet value is sparse.
+  if isinstance(input, float) and math.isnan(input):
+    input = None
+  for prop in reversed(props):
+    input = {prop: input}
+  return input
+
+
+def _wrap_in_dicts(input: Union[object, Iterable[object]],
+                   spec: list[PathTuple]) -> Union[object, Iterable[object]]:
+  """Wraps an object or iterable in a dict according to the spec."""
+  props = spec[0] if spec else tuple()
+  if len(spec) == 1:
+    return _wrap_value_in_dict(input, props)
+  if input is None or isinstance(input, float) and math.isnan(input):
+    # Return empty dict for missing inputs.
+    return {}
+  res = [_wrap_in_dicts(elem, spec[1:]) for elem in cast(Iterable, input)]
+  return _wrap_value_in_dict(res, props)
+
+
+def wrap_in_dicts(input: Iterable[object], spec: list[PathTuple]) -> Iterable[object]:
+  """Wraps an object or iterable in a dict according to the spec."""
+  return [_wrap_in_dicts(elem, spec) for elem in input]
+
+
+def _merge_field_into(schema: Field, destination: Field) -> None:
+  if isinstance(schema, Field):
+    destination.signal = destination.signal or schema.signal
+    destination.dtype = destination.dtype or schema.dtype
+  if schema.fields:
+    destination.fields = destination.fields or {}
+    for field_name, subfield in schema.fields.items():
+      if field_name not in destination.fields:
+        destination.fields[field_name] = subfield.copy(deep=True)
+      else:
+        _merge_field_into(subfield, destination.fields[field_name])
+  elif schema.repeated_field:
+    if not destination.repeated_field:
+      raise ValueError('Failed to merge schemas. Origin schema is repeated, but destination is not')
+    _merge_field_into(schema.repeated_field, destination.repeated_field)
+  else:
+    if destination.dtype != schema.dtype:
+      raise ValueError(f'Failed to merge schemas. Origin schema has dtype {schema.dtype}, '
+                       f'but destination has dtype {destination.dtype}')
+
+
+def merge_schemas(schemas: Sequence[Union[Schema, Field]]) -> Schema:
+  """Merge a list of schemas."""
+  merged_schema = Schema(fields={})
+  for s in schemas:
+    _merge_field_into(cast(Field, s), cast(Field, merged_schema))
+  return merged_schema
+
+
+def schema_contains_path(schema: Schema, path: PathTuple) -> bool:
+  """Check if a schema contains a path."""
+  current_field = cast(Field, schema)
+  for path_part in path:
+    if path_part == PATH_WILDCARD:
+      if current_field.repeated_field is None:
+        return False
+      current_field = current_field.repeated_field
+    else:
+      if current_field.fields is None or path_part not in current_field.fields:
+        return False
+      current_field = current_field.fields[str(path_part)]
+  return True
+
+
+def create_signal_schema(signal: Signal, source_path: PathTuple, current_schema: Schema) -> Schema:
+  """Create a schema describing the enriched fields added an enrichment."""
+  leafs = current_schema.leafs
+  # Validate that the enrich fields are actually a valid leaf path.
+  if source_path not in leafs:
+    raise ValueError(f'"{source_path}" is not a valid leaf path. Leaf paths: {leafs.keys()}')
+
+  signal_schema = signal.fields()
+  signal_schema.signal = signal.dict()
+
+  enriched_schema = field(fields={signal.key(is_computed_signal=True): signal_schema})
+
+  for path_part in reversed(source_path):
+    if path_part == PATH_WILDCARD:
+      enriched_schema = Field(repeated_field=enriched_schema)
+    else:
+      enriched_schema = Field(fields={path_part: enriched_schema})
+
+  if not enriched_schema.fields:
+    raise ValueError('This should not happen since enriched_schema always has fields (see above)')
+
+  return schema(enriched_schema.fields.copy())
+
+
+def write_embeddings_to_disk(vector_store: str, rowids: Iterable[str], signal_items: Iterable[Item],
+                             output_dir: str) -> None:
+  """Write a set of embeddings to disk."""
+
+  def embedding_predicate(input: Any) -> bool:
+    return (isinstance(input, list) and len(input) > 0 and isinstance(input[0], dict) and
+            EMBEDDING_KEY in input[0])
+
+  path_keys = flatten_keys(rowids, signal_items, is_primitive_predicate=embedding_predicate)
+  all_embeddings = cast(Iterable[Item],
+                        deep_flatten(signal_items, is_primitive_predicate=embedding_predicate))
+
+  embedding_vectors: list[np.ndarray] = []
+  all_spans: list[tuple[PathKey, list[tuple[int, int]]]] = []
+  for path_key, embeddings in zip(path_keys, all_embeddings):
+    if not path_key or not embeddings:
+      # Sparse embeddings may not have an embedding for every key.
+      continue
+
+    spans: list[tuple[int, int]] = []
+    for e in embeddings:
+      span = e[VALUE_KEY]
+      vector = e[EMBEDDING_KEY]
+      # We squeeze here because embedding functions can return outer dimensions of 1.
+      embedding_vectors.append(vector.reshape(-1))
+      spans.append((span[TEXT_SPAN_START_FEATURE], span[TEXT_SPAN_END_FEATURE]))
+    all_spans.append((path_key, spans))
+  embedding_matrix = np.array(embedding_vectors, dtype=np.float32)
+  del path_keys, all_embeddings, embedding_vectors
+  gc.collect()
+
+  # Write to disk.
+  vector_index = VectorDBIndex(vector_store)
+  vector_index.add(all_spans, embedding_matrix)
+  vector_index.save(output_dir)
+
+  del vector_index
+  gc.collect()
+
+
+def write_items_to_parquet(items: Iterable[Item], output_dir: str, schema: Schema,
+                           filename_prefix: str, shard_index: int,
+                           num_shards: int) -> tuple[str, int]:
+  """Write a set of items to a parquet file, in columnar format."""
+  schema = schema.copy(deep=True)
+  # Add a rowid column.
+  schema.fields[ROWID] = Field(dtype=DataType.STRING)
+
+  arrow_schema = schema_to_arrow_schema(schema)
+  out_filename = parquet_filename(filename_prefix, shard_index, num_shards)
+  filepath = os.path.join(output_dir, out_filename)
+  f = open_file(filepath, mode='wb')
+  writer = ParquetWriter(schema)
+  writer.open(f)
+  debug = env('DEBUG', False)
+  num_items = 0
+  for item in items:
+    # Add a rowid column.
+    if ROWID not in item:
+      item[ROWID] = secrets.token_urlsafe(nbytes=12)  # 16 base64 characters.
+    if debug:
+      try:
+        _validate(item, arrow_schema)
+      except Exception as e:
+        raise ValueError(f'Error validating item: {json.dumps(item)}') from e
+    writer.write(item)
+    num_items += 1
+  writer.close()
+  f.close()
+  return out_filename, num_items
+
+
+def _validate(item: Item, schema: pa.Schema) -> None:
+  # Try to parse the item using the inferred schema.
+  try:
+    pa.RecordBatch.from_pylist([item], schema=schema)
+  except pa.ArrowTypeError:
+    log('Failed to parse arrow item using the arrow schema.')
+    log('Item:')
+    log(pprint.pformat(item, indent=2))
+    log('Arrow schema:')
+    log(schema)
+    raise  # Re-raise the same exception, same stacktrace.
+
+
+def parquet_filename(prefix: str, shard_index: int, num_shards: int) -> str:
+  """Return the filename for a parquet file."""
+  return f'{prefix}-{shard_index:05d}-of-{num_shards:05d}.parquet'
+
+
+def _flatten_keys(rowid: str, nested_input: Iterable, location: list[int],
+                  is_primitive_predicate: Callable[[object], bool]) -> Iterator[VectorKey]:
+  if is_primitive_predicate(nested_input) or is_primitive(nested_input) or isinstance(
+      nested_input, dict):
+    yield (rowid, *location)
+    return
+
+  for i, input in enumerate(nested_input):
+    yield from _flatten_keys(rowid, input, [*location, i], is_primitive_predicate)
+
+
+def flatten_keys(
+    rowids: Iterable[str],
+    nested_input: Iterable,
+    is_primitive_predicate: Callable[[object],
+                                     bool] = is_primitive) -> Iterator[Optional[VectorKey]]:
+  """Flatten the rowids of a nested input."""
+  for rowid, input in zip(rowids, nested_input):
+    if input is None:
+      yield None
+      continue
+    yield from _flatten_keys(rowid, input, [], is_primitive_predicate)
+
+
+Tin = TypeVar('Tin')
+Tout = TypeVar('Tout')
+
+
+def sparse_to_dense_compute(
+    sparse_input: Iterator[Optional[Tin]],
+    func: Callable[[Iterable[Tin]], Iterable[Tout]]) -> Iterator[Optional[Tout]]:
+  """Densifies the input before calling the provided `func` and sparsifies the output."""
+  locations: list[int] = []
+  total_size: int = 0
+
+  def densify(x: Iterator[Optional[Tin]]) -> Iterator[Tin]:
+    nonlocal locations, total_size
+    for i, value in enumerate(x):
+      total_size += 1
+      if value is not None:
+        locations.append(i)
+        yield value
+
+  dense_input = densify(sparse_input)
+  dense_output = iter(func(dense_input))
+  index = 0
+
+  location_index = 0
+
+  while True:
+    try:
+      out = next(dense_output)
+      out_index = locations[location_index]
+      while index < out_index:
+        yield None
+        index += 1
+      yield out
+      location_index += 1
+      index += 1
+    except StopIteration:
+      while index < total_size:
+        yield None
+        index += 1
+      return

lilac/data_loader.py

@@ -0,0 +1,110 @@
+"""A data loader standalone binary. This should only be run as a script to load a dataset.
+
+To run the source loader as a binary directly:
+
+poetry run python -m lilac.data_loader \
+  --dataset_name=movies_dataset \
+  --output_dir=./data/ \
+  --config_path=./datasets/the_movies_dataset.json
+"""
+import os
+import pathlib
+import uuid
+from typing import Iterable, Optional, Union
+
+import pandas as pd
+
+from .config import CONFIG_FILENAME, DatasetConfig
+from .data.dataset import Dataset, default_settings
+from .data.dataset_utils import write_items_to_parquet
+from .db_manager import get_dataset
+from .env import data_path
+from .schema import (
+  MANIFEST_FILENAME,
+  PARQUET_FILENAME_PREFIX,
+  ROWID,
+  Field,
+  Item,
+  Schema,
+  SourceManifest,
+  is_float,
+)
+from .tasks import TaskStepId, progress
+from .utils import get_dataset_output_dir, log, open_file, to_yaml
+
+
+def create_dataset(config: DatasetConfig) -> Dataset:
+  """Load a dataset from a given source configuration."""
+  process_source(data_path(), config)
+  return get_dataset(config.namespace, config.name)
+
+
+def process_source(base_dir: Union[str, pathlib.Path],
+                   config: DatasetConfig,
+                   task_step_id: Optional[TaskStepId] = None) -> tuple[str, int]:
+  """Process a source."""
+  output_dir = get_dataset_output_dir(base_dir, config.namespace, config.name)
+
+  config.source.setup()
+  source_schema = config.source.source_schema()
+  items = config.source.process()
+
+  # Add rowids and fix NaN in string columns.
+  items = normalize_items(items, source_schema.fields)
+
+  # Add progress.
+  items = progress(
+    items,
+    task_step_id=task_step_id,
+    estimated_len=source_schema.num_items,
+    step_description=f'Reading from source {config.source.name}...')
+
+  # Filter out the `None`s after progress.
+  items = (item for item in items if item is not None)
+
+  data_schema = Schema(fields=source_schema.fields.copy())
+  filepath, num_items = write_items_to_parquet(
+    items=items,
+    output_dir=output_dir,
+    schema=data_schema,
+    filename_prefix=PARQUET_FILENAME_PREFIX,
+    shard_index=0,
+    num_shards=1)
+
+  filenames = [os.path.basename(filepath)]
+  manifest = SourceManifest(files=filenames, data_schema=data_schema, images=None)
+  with open_file(os.path.join(output_dir, MANIFEST_FILENAME), 'w') as f:
+    f.write(manifest.json(indent=2, exclude_none=True))
+
+  if not config.settings:
+    dataset = get_dataset(config.namespace, config.name)
+    config.settings = default_settings(dataset)
+  with open_file(os.path.join(output_dir, CONFIG_FILENAME), 'w') as f:
+    f.write(to_yaml(config.dict(exclude_defaults=True, exclude_none=True)))
+
+  log(f'Dataset "{config.name}" written to {output_dir}')
+
+  return output_dir, num_items
+
+
+def normalize_items(items: Iterable[Item], fields: dict[str, Field]) -> Item:
+  """Sanitize items by removing NaNs and NaTs."""
+  replace_nan_fields = [
+    field_name for field_name, field in fields.items() if field.dtype and not is_float(field.dtype)
+  ]
+  for item in items:
+    if item is None:
+      yield item
+      continue
+
+    # Add rowid if it doesn't exist.
+    if ROWID not in item:
+      item[ROWID] = uuid.uuid4().hex
+
+    # Fix NaN values.
+    for field_name in replace_nan_fields:
+      item_value = item.get(field_name)
+      if item_value and pd.isna(item_value):
+        item[field_name] = None
+
+    yield item

lilac/db_manager.py

@@ -0,0 +1,96 @@
+"""Manages mapping the dataset name to the database instance."""
+import os
+import pathlib
+import threading
+from typing import Optional, Type, Union
+
+import yaml
+from pydantic import BaseModel
+
+from .config import DatasetConfig
+from .data.dataset import Dataset
+from .data.dataset_duckdb import get_config_filepath
+from .utils import get_datasets_dir
+
+_DEFAULT_DATASET_CLS: Type[Dataset]
+
+_CACHED_DATASETS: dict[str, Dataset] = {}
+
+_db_lock = threading.Lock()
+
+
+def get_dataset(namespace: str, dataset_name: str) -> Dataset:
+  """Get the dataset instance."""
+  if not _DEFAULT_DATASET_CLS:
+    raise ValueError('Default dataset class not set.')
+  cache_key = f'{namespace}/{dataset_name}'
+  # https://docs.pytest.org/en/latest/example/simple.html#pytest-current-test-environment-variable
+  inside_test = 'PYTEST_CURRENT_TEST' in os.environ
+  with _db_lock:
+    if cache_key not in _CACHED_DATASETS or inside_test:
+      _CACHED_DATASETS[cache_key] = _DEFAULT_DATASET_CLS(
+        namespace=namespace, dataset_name=dataset_name)
+    return _CACHED_DATASETS[cache_key]
+
+
+def remove_dataset_from_cache(namespace: str, dataset_name: str) -> None:
+  """Remove the dataset from the db manager cache."""
+  cache_key = f'{namespace}/{dataset_name}'
+  with _db_lock:
+    if cache_key in _CACHED_DATASETS:
+      del _CACHED_DATASETS[cache_key]
+
+
+class DatasetInfo(BaseModel):
+  """Information about a dataset."""
+  namespace: str
+  dataset_name: str
+  description: Optional[str] = None
+  tags: list[str] = []
+
+
+def list_datasets(base_dir: Union[str, pathlib.Path]) -> list[DatasetInfo]:
+  """List the datasets in a data directory."""
+  datasets_path = get_datasets_dir(base_dir)
+
+  # Skip if 'datasets' doesn't exist.
+  if not os.path.isdir(datasets_path):
+    return []
+
+  dataset_infos: list[DatasetInfo] = []
+  for namespace in os.listdir(datasets_path):
+    dataset_dir = os.path.join(datasets_path, namespace)
+    # Skip if namespace is not a directory.
+    if not os.path.isdir(dataset_dir):
+      continue
+    if namespace.startswith('.'):
+      continue
+
+    for dataset_name in os.listdir(dataset_dir):
+      # Skip if dataset_name is not a directory.
+      dataset_path = os.path.join(dataset_dir, dataset_name)
+      if not os.path.isdir(dataset_path):
+        continue
+      if dataset_name.startswith('.'):
+        continue
+
+      # Open the config file to read the tags. We avoid instantiating a dataset for now to reduce
+      # the overhead of listing datasets.
+      config_filepath = get_config_filepath(namespace, dataset_name)
+      tags = []
+      if os.path.exists(config_filepath):
+        with open(config_filepath) as f:
+          config = DatasetConfig(**yaml.safe_load(f))
+        tags = config.tags
+
+      dataset_infos.append(DatasetInfo(namespace=namespace, dataset_name=dataset_name, tags=tags))
+
+  return dataset_infos
+
+
+# TODO(nsthorat): Make this a registry once we have multiple dataset implementations. This breaks a
+# circular dependency.
+def set_default_dataset_cls(dataset_cls: Type[Dataset]) -> None:
+  """Set the default dataset class."""
+  global _DEFAULT_DATASET_CLS
+  _DEFAULT_DATASET_CLS = dataset_cls

lilac/embeddings/__init__.py

@@ -0,0 +1,7 @@
+"""Embeddings compute a vector for a chunk of a document."""
+
+from .embedding import compute_split_embeddings
+
+__all__ = [
+  'compute_split_embeddings',
+]

lilac/embeddings/cohere.py

@@ -0,0 +1,59 @@
+"""Cohere embeddings."""
+from typing import TYPE_CHECKING, Iterable, cast
+
+import numpy as np
+from typing_extensions import override
+
+from ..env import env
+from ..schema import Item, RichData
+from ..signal import TextEmbeddingSignal
+from ..splitters.chunk_splitter import split_text
+from .embedding import compute_split_embeddings
+
+if TYPE_CHECKING:
+  from cohere import Client
+
+NUM_PARALLEL_REQUESTS = 10
+COHERE_BATCH_SIZE = 96
+
+
+class Cohere(TextEmbeddingSignal):
+  """Computes embeddings using Cohere's embedding API.
+
+  <br>**Important**: This will send data to an external server!
+
+  <br>To use this signal, you must get a Cohere API key from
+  [cohere.com/embed](https://cohere.com/embed) and add it to your .env.local.
+
+  <br>For details on pricing, see: https://cohere.com/pricing.
+  """
+
+  name = 'cohere'
+  display_name = 'Cohere Embeddings'
+
+  _model: 'Client'
+
+  @override
+  def setup(self) -> None:
+    """Validate that the api key and python package exists in environment."""
+    api_key = env('COHERE_API_KEY')
+    if not api_key:
+      raise ValueError('`COHERE_API_KEY` environment variable not set.')
+    try:
+      import cohere
+      self._model = cohere.Client(api_key, max_retries=10)
+    except ImportError:
+      raise ImportError('Could not import the "cohere" python package. '
+                        'Please install it with `pip install cohere`.')
+
+  @override
+  def compute(self, docs: Iterable[RichData]) -> Iterable[Item]:
+    """Compute embeddings for the given documents."""
+
+    def embed_fn(texts: list[str]) -> list[np.ndarray]:
+      return self._model.embed(texts, truncate='END').embeddings
+
+    docs = cast(Iterable[str], docs)
+    split_fn = split_text if self._split else None
+    yield from compute_split_embeddings(
+      docs, COHERE_BATCH_SIZE, embed_fn, split_fn, num_parallel_requests=NUM_PARALLEL_REQUESTS)

lilac/embeddings/default_vector_stores.py

@@ -0,0 +1,10 @@
+"""Registers all vector stores."""
+from .vector_store import register_vector_store
+from .vector_store_hnsw import HNSWVectorStore
+from .vector_store_numpy import NumpyVectorStore
+
+
+def register_default_vector_stores() -> None:
+  """Register all the default vector stores."""
+  register_vector_store(HNSWVectorStore)
+  register_vector_store(NumpyVectorStore)

lilac/embeddings/embedding.py

@@ -0,0 +1,110 @@
+"""Embedding registry."""
+from concurrent.futures import ThreadPoolExecutor
+from typing import Callable, Generator, Iterable, Iterator, Optional, Union, cast
+
+import numpy as np
+from pydantic import StrictStr
+from sklearn.preprocessing import normalize
+
+from ..schema import (
+  EMBEDDING_KEY,
+  TEXT_SPAN_END_FEATURE,
+  TEXT_SPAN_START_FEATURE,
+  VALUE_KEY,
+  Item,
+  RichData,
+  SpanVector,
+  lilac_embedding,
+)
+from ..signal import TextEmbeddingSignal, get_signal_by_type
+from ..splitters.chunk_splitter import TextChunk
+from ..utils import chunks
+
+EmbeddingId = Union[StrictStr, TextEmbeddingSignal]
+
+EmbedFn = Callable[[Iterable[RichData]], Iterator[list[SpanVector]]]
+
+
+def get_embed_fn(embedding_name: str, split: bool) -> EmbedFn:
+  """Return a function that returns the embedding matrix for the given embedding signal."""
+  embedding_cls = get_signal_by_type(embedding_name, TextEmbeddingSignal)
+  embedding = embedding_cls(split=split)
+  embedding.setup()
+
+  def _embed_fn(data: Iterable[RichData]) -> Iterator[list[SpanVector]]:
+    items = embedding.compute(data)
+
+    for item in items:
+      if not item:
+        raise ValueError('Embedding signal returned None.')
+
+      yield [{
+        'vector': item_val[EMBEDDING_KEY].reshape(-1),
+        'span':
+          (item_val[VALUE_KEY][TEXT_SPAN_START_FEATURE], item_val[VALUE_KEY][TEXT_SPAN_END_FEATURE])
+      } for item_val in item]
+
+  return _embed_fn
+
+
+def compute_split_embeddings(docs: Iterable[str],
+                             batch_size: int,
+                             embed_fn: Callable[[list[str]], list[np.ndarray]],
+                             split_fn: Optional[Callable[[str], list[TextChunk]]] = None,
+                             num_parallel_requests: int = 1) -> Generator[Item, None, None]:
+  """Compute text embeddings in batches of chunks, using the provided splitter and embedding fn."""
+  pool = ThreadPoolExecutor()
+
+  def _splitter(doc: str) -> list[TextChunk]:
+    if not doc:
+      return []
+    if split_fn:
+      return split_fn(doc)
+    else:
+      # Return a single chunk that spans the entire document.
+      return [(doc, (0, len(doc)))]
+
+  num_docs = 0
+
+  def _flat_split_batch_docs(docs: Iterable[str]) -> Generator[tuple[int, TextChunk], None, None]:
+    """Split a batch of documents into chunks and yield them."""
+    nonlocal num_docs
+    for i, doc in enumerate(docs):
+      num_docs += 1
+      chunks = _splitter(doc)
+      for chunk in chunks:
+        yield (i, chunk)
+
+  doc_chunks = _flat_split_batch_docs(docs)
+  items_to_yield: Optional[list[Item]] = None
+  current_index = 0
+
+  mega_batch_size = batch_size * num_parallel_requests
+
+  for batch in chunks(doc_chunks, mega_batch_size):
+    texts = [text for _, (text, _) in batch]
+    embeddings: list[np.ndarray] = []
+
+    for x in list(pool.map(lambda x: embed_fn(x), chunks(texts, batch_size))):
+      embeddings.extend(x)
+    matrix = cast(np.ndarray, normalize(np.array(embeddings, dtype=np.float32)))
+    # np.split returns a shallow copy of each embedding so we don't increase the mem footprint.
+    embeddings_batch = cast(list[np.ndarray], np.split(matrix, matrix.shape[0]))
+    for (index, (_, (start, end))), embedding in zip(batch, embeddings_batch):
+      embedding = embedding.reshape(-1)
+      if index == current_index:
+        if items_to_yield is None:
+          items_to_yield = []
+        items_to_yield.append(lilac_embedding(start, end, embedding))
+      else:
+        yield items_to_yield
+        current_index += 1
+        while current_index < index:
+          yield None
+          current_index += 1
+        items_to_yield = [lilac_embedding(start, end, embedding)]
+
+  while current_index < num_docs:
+    yield items_to_yield
+    items_to_yield = None
+    current_index += 1

lilac/embeddings/gte.py

@@ -0,0 +1,63 @@
+"""Gegeral Text Embeddings (GTE) model. Open-source model, designed to run on device."""
+from typing import TYPE_CHECKING, Iterable, cast
+
+from typing_extensions import override
+
+from ..schema import Item, RichData
+from ..signal import TextEmbeddingSignal
+from ..splitters.chunk_splitter import split_text
+from .embedding import compute_split_embeddings
+from .transformer_utils import get_model
+
+if TYPE_CHECKING:
+  pass
+
+# See https://huggingface.co/spaces/mteb/leaderboard for leaderboard of models.
+GTE_SMALL = 'thenlper/gte-small'
+GTE_BASE = 'thenlper/gte-base'
+
+# Maps a tuple of model name and device to the optimal batch size, found empirically.
+_OPTIMAL_BATCH_SIZES: dict[str, dict[str, int]] = {
+  GTE_SMALL: {
+    '': 64,  # Default batch size.
+    'mps': 256,
+  },
+  GTE_BASE: {
+    '': 64,  # Default batch size.
+    'mps': 128,
+  }
+}
+
+
+class GTESmall(TextEmbeddingSignal):
+  """Computes Gegeral Text Embeddings (GTE).
+
+  <br>This embedding runs on-device. See the [model card](https://huggingface.co/thenlper/gte-small)
+  for details.
+  """
+
+  name = 'gte-small'
+  display_name = 'Gegeral Text Embeddings (small)'
+
+  _model_name = GTE_SMALL
+
+  @override
+  def compute(self, docs: Iterable[RichData]) -> Iterable[Item]:
+    """Call the embedding function."""
+    batch_size, model = get_model(self._model_name, _OPTIMAL_BATCH_SIZES[self._model_name])
+    embed_fn = model.encode
+    split_fn = split_text if self._split else None
+    docs = cast(Iterable[str], docs)
+    yield from compute_split_embeddings(docs, batch_size, embed_fn=embed_fn, split_fn=split_fn)
+
+
+class GTEBase(GTESmall):
+  """Computes Gegeral Text Embeddings (GTE).
+
+  <br>This embedding runs on-device. See the [model card](https://huggingface.co/thenlper/gte-base)
+  for details.
+  """
+  name = 'gte-base'
+  display_name = 'Gegeral Text Embeddings (base)'
+
+  _model_name = GTE_BASE

lilac/embeddings/openai.py

@@ -0,0 +1,68 @@
+"""OpenAI embeddings."""
+from typing import TYPE_CHECKING, Any, Iterable, cast
+
+import numpy as np
+from tenacity import retry, stop_after_attempt, wait_random_exponential
+from typing_extensions import override
+
+from ..env import env
+from ..schema import Item, RichData
+from ..signal import TextEmbeddingSignal
+from ..splitters.chunk_splitter import split_text
+from .embedding import compute_split_embeddings
+
+if TYPE_CHECKING:
+  import openai
+
+NUM_PARALLEL_REQUESTS = 10
+OPENAI_BATCH_SIZE = 128
+EMBEDDING_MODEL = 'text-embedding-ada-002'
+
+
+class OpenAI(TextEmbeddingSignal):
+  """Computes embeddings using OpenAI's embedding API.
+
+  <br>**Important**: This will send data to an external server!
+
+  <br>To use this signal, you must get an OpenAI API key from
+  [platform.openai.com](https://platform.openai.com/) and add it to your .env.local.
+
+  <br>For details on pricing, see: https://openai.com/pricing.
+  """
+
+  name = 'openai'
+  display_name = 'OpenAI Embeddings'
+
+  _model: type['openai.Embedding']
+
+  @override
+  def setup(self) -> None:
+    api_key = env('OPENAI_API_KEY')
+    if not api_key:
+      raise ValueError('`OPENAI_API_KEY` environment variable not set.')
+    try:
+      import openai
+      openai.api_key = api_key
+      self._model = openai.Embedding
+    except ImportError:
+      raise ImportError('Could not import the "openai" python package. '
+                        'Please install it with `pip install openai`.')
+
+  @override
+  def compute(self, docs: Iterable[RichData]) -> Iterable[Item]:
+    """Compute embeddings for the given documents."""
+
+    @retry(wait=wait_random_exponential(min=1, max=20), stop=stop_after_attempt(10))
+    def embed_fn(texts: list[str]) -> list[np.ndarray]:
+
+      # Replace newlines, which can negatively affect performance.
+      # See https://github.com/search?q=repo%3Aopenai%2Fopenai-python+replace+newlines&type=code
+      texts = [text.replace('\n', ' ') for text in texts]
+
+      response: Any = self._model.create(input=texts, model=EMBEDDING_MODEL)
+      return [np.array(embedding['embedding'], dtype=np.float32) for embedding in response['data']]
+
+    docs = cast(Iterable[str], docs)
+    split_fn = split_text if self._split else None
+    yield from compute_split_embeddings(
+      docs, OPENAI_BATCH_SIZE, embed_fn, split_fn, num_parallel_requests=NUM_PARALLEL_REQUESTS)

lilac/embeddings/palm.py

@@ -0,0 +1,62 @@
+"""PaLM embeddings."""
+from typing import TYPE_CHECKING, Iterable, cast
+
+import numpy as np
+from tenacity import retry, stop_after_attempt, wait_random_exponential
+from typing_extensions import override
+
+from ..env import env
+from ..schema import Item, RichData
+from ..signal import TextEmbeddingSignal
+from ..splitters.chunk_splitter import split_text
+from .embedding import compute_split_embeddings
+
+if TYPE_CHECKING:
+  import google.generativeai as palm
+
+PALM_BATCH_SIZE = 1  # PaLM API only supports batch size 1.
+NUM_PARALLEL_REQUESTS = 256  # Because batch size is 1, we can send many requests in parallel.
+EMBEDDING_MODEL = 'models/embedding-gecko-001'
+
+
+class PaLM(TextEmbeddingSignal):
+  """Computes embeddings using PaLM's embedding API.
+
+  <br>**Important**: This will send data to an external server!
+
+  <br>To use this signal, you must get a PaLM API key from
+  [makersuite.google.com](https://makersuite.google.com/app/apikey) and add it to your .env.local.
+  """
+
+  name = 'palm'
+  display_name = 'PaLM Embeddings'
+
+  _model: 'palm.generate_embeddings'
+
+  @override
+  def setup(self) -> None:
+    api_key = env('PALM_API_KEY')
+    if not api_key:
+      raise ValueError('`PALM_API_KEY` environment variable not set.')
+    try:
+      import google.generativeai as palm
+      palm.configure(api_key=api_key)
+      self._model = palm.generate_embeddings
+    except ImportError:
+      raise ImportError('Could not import the "google.generativeai" python package. '
+                        'Please install it with `pip install google-generativeai`.')
+
+  @override
+  def compute(self, docs: Iterable[RichData]) -> Iterable[Item]:
+    """Compute embeddings for the given documents."""
+
+    @retry(wait=wait_random_exponential(min=1, max=20), stop=stop_after_attempt(10))
+    def embed_fn(texts: list[str]) -> list[np.ndarray]:
+      assert len(texts) == 1, 'PaLM API only supports batch size 1.'
+      response = self._model(model=EMBEDDING_MODEL, text=texts[0])
+      return [np.array(response['embedding'], dtype=np.float32)]
+
+    docs = cast(Iterable[str], docs)
+    split_fn = split_text if self._split else None
+    yield from compute_split_embeddings(
+      docs, PALM_BATCH_SIZE, embed_fn, split_fn, num_parallel_requests=NUM_PARALLEL_REQUESTS)

lilac/embeddings/sbert.py

@@ -0,0 +1,38 @@
+"""Sentence-BERT embeddings. Open-source models, designed to run on device."""
+from typing import Iterable, cast
+
+from typing_extensions import override
+
+from ..schema import Item, RichData
+from ..signal import TextEmbeddingSignal
+from ..splitters.chunk_splitter import split_text
+from .embedding import compute_split_embeddings
+from .transformer_utils import get_model
+
+# The `all-mpnet-base-v2` model provides the best quality, while `all-MiniLM-L6-v2`` is 5 times
+# faster and still offers good quality. See https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models/
+MINI_LM_MODEL = 'all-MiniLM-L6-v2'
+
+# Maps a tuple of model name and device to the optimal batch size, found empirically.
+_OPTIMAL_BATCH_SIZES: dict[str, dict[str, int]] = {
+  MINI_LM_MODEL: {
+    '': 64,  # Default batch size.
+    'mps': 256,
+  }
+}
+
+
+class SBERT(TextEmbeddingSignal):
+  """Computes embeddings using Sentence-BERT library."""
+
+  name = 'sbert'
+  display_name = 'SBERT Embeddings'
+
+  @override
+  def compute(self, docs: Iterable[RichData]) -> Iterable[Item]:
+    """Call the embedding function."""
+    batch_size, model = get_model(MINI_LM_MODEL, _OPTIMAL_BATCH_SIZES[MINI_LM_MODEL])
+    embed_fn = model.encode
+    split_fn = split_text if self._split else None
+    docs = cast(Iterable[str], docs)
+    yield from compute_split_embeddings(docs, batch_size, embed_fn=embed_fn, split_fn=split_fn)

lilac/embeddings/transformer_utils.py

@@ -0,0 +1,35 @@
+"""Utils for transformer embeddings."""
+
+import functools
+import os
+from typing import TYPE_CHECKING, Optional
+
+from ..env import data_path
+from ..utils import log
+
+if TYPE_CHECKING:
+  from sentence_transformers import SentenceTransformer
+
+
+def get_model(model_name: str,
+              optimal_batch_sizes: dict[str, int] = {}) -> tuple[int, 'SentenceTransformer']:
+  """Get a transformer model and the optimal batch size for it."""
+  try:
+    import torch.backends.mps
+    from sentence_transformers import SentenceTransformer
+  except ImportError:
+    raise ImportError('Could not import the "sentence_transformers" python package. '
+                      'Please install it with `pip install sentence-transformers`.')
+  preferred_device: Optional[str] = None
+  if torch.backends.mps.is_available():
+    preferred_device = 'mps'
+  elif not torch.backends.mps.is_built():
+    log('MPS not available because the current PyTorch install was not built with MPS enabled.')
+
+  @functools.cache
+  def _get_model(model_name: str) -> 'SentenceTransformer':
+    return SentenceTransformer(
+      model_name, device=preferred_device, cache_folder=os.path.join(data_path(), '.cache'))
+
+  batch_size = optimal_batch_sizes[preferred_device or '']
+  return batch_size, _get_model(model_name)

lilac/embeddings/vector_store.py

@@ -0,0 +1,201 @@
+"""Interface for storing vectors."""
+
+import abc
+import os
+import pickle
+from typing import Iterable, Optional, Type
+
+import numpy as np
+
+from ..schema import SpanVector, VectorKey
+from ..utils import open_file
+
+
+class VectorStore(abc.ABC):
+  """Interface for storing and retrieving vectors."""
+
+  # The global name of the vector store.
+  name: str
+
+  @abc.abstractmethod
+  def save(self, base_path: str) -> None:
+    """Save the store to disk."""
+    pass
+
+  @abc.abstractmethod
+  def load(self, base_path: str) -> None:
+    """Load the store from disk."""
+    pass
+
+  @abc.abstractmethod
+  def size(self) -> int:
+    """Return the number of vectors in the store."""
+    pass
+
+  @abc.abstractmethod
+  def add(self, keys: list[VectorKey], embeddings: np.ndarray) -> None:
+    """Add or edit the given keyed embeddings to the store.
+
+    If the keys already exist they will be overwritten, acting as an "upsert".
+
+    Args:
+      keys: The keys to add the embeddings for.
+      embeddings: The embeddings to add. This should be a 2D matrix with the same length as keys.
+    """
+    pass
+
+  @abc.abstractmethod
+  def get(self, keys: Optional[Iterable[VectorKey]] = None) -> np.ndarray:
+    """Return the embeddings for given keys.
+
+    Args:
+      keys: The keys to return the embeddings for. If None, return all embeddings.
+
+    Returns
+      The embeddings for the given keys.
+    """
+    pass
+
+  def topk(self,
+           query: np.ndarray,
+           k: int,
+           keys: Optional[Iterable[VectorKey]] = None) -> list[tuple[VectorKey, float]]:
+    """Return the top k most similar vectors.
+
+    Args:
+      query: The query vector.
+      k: The number of results to return.
+      keys: Optional keys to restrict the search to.
+
+    Returns
+      A list of (key, score) tuples.
+    """
+    raise NotImplementedError
+
+
+PathKey = VectorKey
+
+_SPANS_PICKLE_NAME = 'spans.pkl'
+
+
+class VectorDBIndex:
+  """Stores and retrives span vectors.
+
+  This wraps a regular vector store by adding a mapping from path keys, such as (rowid1, 0),
+  to span keys, such as (rowid1, 0, 0), which denotes the first span in the (rowid1, 0) document.
+  """
+
+  def __init__(self, vector_store: str) -> None:
+    self._vector_store: VectorStore = get_vector_store_cls(vector_store)()
+    # Map a path key to spans for that path.
+    self._id_to_spans: dict[PathKey, list[tuple[int, int]]] = {}
+
+  def load(self, base_path: str) -> None:
+    """Load the vector index from disk."""
+    assert not self._id_to_spans, 'Cannot load into a non-empty index.'
+    with open_file(os.path.join(base_path, _SPANS_PICKLE_NAME), 'rb') as f:
+      self._id_to_spans.update(pickle.load(f))
+    self._vector_store.load(os.path.join(base_path, self._vector_store.name))
+
+  def save(self, base_path: str) -> None:
+    """Save the vector index to disk."""
+    assert self._id_to_spans, 'Cannot save an empty index.'
+    with open_file(os.path.join(base_path, _SPANS_PICKLE_NAME), 'wb') as f:
+      pickle.dump(list(self._id_to_spans.items()), f)
+    self._vector_store.save(os.path.join(base_path, self._vector_store.name))
+
+  def add(self, all_spans: list[tuple[PathKey, list[tuple[int, int]]]],
+          embeddings: np.ndarray) -> None:
+    """Add the given spans and embeddings.
+
+    Args:
+      all_spans: The spans to initialize the index with.
+      embeddings: The embeddings to initialize the index with.
+    """
+    assert not self._id_to_spans, 'Cannot add to a non-empty index.'
+    self._id_to_spans.update(all_spans)
+    vector_keys = [(*path_key, i) for path_key, spans in all_spans for i in range(len(spans))]
+    assert len(vector_keys) == len(embeddings), (
+      f'Number of spans ({len(vector_keys)}) and embeddings ({len(embeddings)}) must match.')
+    self._vector_store.add(vector_keys, embeddings)
+
+  def get_vector_store(self) -> VectorStore:
+    """Return the underlying vector store."""
+    return self._vector_store
+
+  def get(self, keys: Iterable[PathKey]) -> Iterable[list[SpanVector]]:
+    """Return the spans with vectors for each key in `keys`.
+
+    Args:
+      keys: The keys to return the vectors for.
+
+    Returns
+      The span vectors for the given keys.
+    """
+    all_spans: list[list[tuple[int, int]]] = []
+    vector_keys: list[VectorKey] = []
+    for path_key in keys:
+      spans = self._id_to_spans[path_key]
+      all_spans.append(spans)
+      vector_keys.extend([(*path_key, i) for i in range(len(spans))])
+
+    all_vectors = self._vector_store.get(vector_keys)
+    offset = 0
+    for spans in all_spans:
+      vectors = all_vectors[offset:offset + len(spans)]
+      yield [{'span': span, 'vector': vector} for span, vector in zip(spans, vectors)]
+      offset += len(spans)
+
+  def topk(self,
+           query: np.ndarray,
+           k: int,
+           path_keys: Optional[Iterable[PathKey]] = None) -> list[tuple[PathKey, float]]:
+    """Return the top k most similar vectors.
+
+    Args:
+      query: The query vector.
+      k: The number of results to return.
+      path_keys: Optional key prefixes to restrict the search to.
+
+    Returns
+      A list of (key, score) tuples.
+    """
+    span_keys: Optional[list[VectorKey]] = None
+    if path_keys is not None:
+      span_keys = [
+        (*path_key, i) for path_key in path_keys for i in range(len(self._id_to_spans[path_key]))
+      ]
+    span_k = k
+    path_key_scores: dict[PathKey, float] = {}
+    total_num_span_keys = self._vector_store.size()
+    while (len(path_key_scores) < k and span_k < total_num_span_keys and
+           (not span_keys or span_k < len(span_keys))):
+      span_k += k
+      vector_key_scores = self._vector_store.topk(query, span_k, span_keys)
+      for (*path_key_list, _), score in vector_key_scores:
+        path_key = tuple(path_key_list)
+        if path_key not in path_key_scores:
+          path_key_scores[path_key] = score
+
+    return list(path_key_scores.items())[:k]
+
+
+VECTOR_STORE_REGISTRY: dict[str, Type[VectorStore]] = {}
+
+
+def register_vector_store(vector_store_cls: Type[VectorStore]) -> None:
+  """Register a vector store in the global registry."""
+  if vector_store_cls.name in VECTOR_STORE_REGISTRY:
+    raise ValueError(f'Vector store "{vector_store_cls.name}" has already been registered!')
+
+  VECTOR_STORE_REGISTRY[vector_store_cls.name] = vector_store_cls
+
+
+def get_vector_store_cls(vector_store_name: str) -> Type[VectorStore]:
+  """Return a registered vector store given the name in the registry."""
+  return VECTOR_STORE_REGISTRY[vector_store_name]
+
+
+def clear_vector_store_registry() -> None:
+  """Clear the vector store registry."""
+  VECTOR_STORE_REGISTRY.clear()

lilac/embeddings/vector_store_hnsw.py

@@ -0,0 +1,112 @@
+"""HNSW vector store."""
+
+import multiprocessing
+from typing import Iterable, Optional, Set, cast
+
+import hnswlib
+import numpy as np
+import pandas as pd
+from typing_extensions import override
+
+from ..schema import VectorKey
+from ..utils import DebugTimer
+from .vector_store import VectorStore
+
+_HNSW_SUFFIX = '.hnswlib.bin'
+_LOOKUP_SUFFIX = '.lookup.pkl'
+
+# Parameters for HNSW index: https://github.com/nmslib/hnswlib/blob/master/ALGO_PARAMS.md
+QUERY_EF = 50
+CONSTRUCTION_EF = 100
+M = 16
+SPACE = 'ip'
+
+
+class HNSWVectorStore(VectorStore):
+  """HNSW-backed vector store."""
+
+  name = 'hnsw'
+
+  def __init__(self) -> None:
+    # Maps a `VectorKey` to a row index in `_embeddings`.
+    self._key_to_label: Optional[pd.Series] = None
+    self._index: Optional[hnswlib.Index] = None
+
+  @override
+  def save(self, base_path: str) -> None:
+    assert self._key_to_label is not None and self._index is not None, (
+      'The vector store has no embeddings. Call load() or add() first.')
+    self._index.save_index(base_path + _HNSW_SUFFIX)
+    self._key_to_label.to_pickle(base_path + _LOOKUP_SUFFIX)
+
+  @override
+  def load(self, base_path: str) -> None:
+    self._key_to_label = pd.read_pickle(base_path + _LOOKUP_SUFFIX)
+    dim = int(self._key_to_label.name)
+    index = hnswlib.Index(space=SPACE, dim=dim)
+    index.set_ef(QUERY_EF)
+    index.set_num_threads(multiprocessing.cpu_count())
+    index.load_index(base_path + _HNSW_SUFFIX)
+    self._index = index
+
+  @override
+  def size(self) -> int:
+    assert self._index is not None, (
+      'The vector store has no embeddings. Call load() or add() first.')
+    return self._index.get_current_count()
+
+  @override
+  def add(self, keys: list[VectorKey], embeddings: np.ndarray) -> None:
+    assert self._index is None, (
+      'Embeddings already exist in this store. Upsert is not yet supported.')
+
+    if len(keys) != embeddings.shape[0]:
+      raise ValueError(
+        f'Length of keys ({len(keys)}) does not match number of embeddings {embeddings.shape[0]}.')
+
+    dim = embeddings.shape[1]
+    with DebugTimer('hnswlib index creation'):
+      index = hnswlib.Index(space=SPACE, dim=dim)
+      index.set_ef(QUERY_EF)
+      index.set_num_threads(multiprocessing.cpu_count())
+      index.init_index(max_elements=len(keys), ef_construction=CONSTRUCTION_EF, M=M)
+
+      # Cast to float32 since dot product with float32 is 40-50x faster than float16 and 2.5x faster
+      # than float64.
+      embeddings = embeddings.astype(np.float32)
+      row_indices = np.arange(len(keys), dtype=np.int32)
+      self._key_to_label = pd.Series(row_indices, index=keys, dtype=np.int32)
+      self._key_to_label.name = str(dim)
+      index.add_items(embeddings, row_indices)
+      self._index = index
+
+  @override
+  def get(self, keys: Optional[Iterable[VectorKey]] = None) -> np.ndarray:
+    assert self._index is not None and self._key_to_label is not None, (
+      'No embeddings exist in this store.')
+    if not keys:
+      return np.array(self._index.get_items(self._key_to_label.values), dtype=np.float32)
+    locs = self._key_to_label.loc[cast(list[str], keys)].values
+    return np.array(self._index.get_items(locs), dtype=np.float32)
+
+  @override
+  def topk(self,
+           query: np.ndarray,
+           k: int,
+           keys: Optional[Iterable[VectorKey]] = None) -> list[tuple[VectorKey, float]]:
+    assert self._index is not None and self._key_to_label is not None, (
+      'No embeddings exist in this store.')
+    labels: Set[int] = set()
+    if keys is not None:
+      labels = set(self._key_to_label.loc[cast(list[str], keys)].tolist())
+      k = min(k, len(labels))
+
+    def filter_func(label: int) -> bool:
+      return label in labels
+
+    query = np.expand_dims(query.astype(np.float32), axis=0)
+    locs, dists = self._index.knn_query(query, k=k, filter=filter_func if labels else None)
+    locs = locs[0]
+    dists = dists[0]
+    topk_keys = self._key_to_label.index.values[locs]
+    return [(key, 1 - dist) for key, dist in zip(topk_keys, dists)]

lilac/embeddings/vector_store_numpy.py

@@ -0,0 +1,92 @@
+"""NumpyVectorStore class for storing vectors in numpy arrays."""
+
+from typing import Iterable, Optional, cast
+
+import numpy as np
+import pandas as pd
+from typing_extensions import override
+
+from ..schema import VectorKey
+from .vector_store import VectorStore
+
+_EMBEDDINGS_SUFFIX = '.matrix.npy'
+_LOOKUP_SUFFIX = '.lookup.pkl'
+
+
+class NumpyVectorStore(VectorStore):
+  """Stores vectors as in-memory np arrays."""
+  name = 'numpy'
+
+  def __init__(self) -> None:
+    self._embeddings: Optional[np.ndarray] = None
+    # Maps a `VectorKey` to a row index in `_embeddings`.
+    self._key_to_index: Optional[pd.Series] = None
+
+  @override
+  def size(self) -> int:
+    assert self._embeddings is not None, (
+      'The vector store has no embeddings. Call load() or add() first.')
+    return len(self._embeddings)
+
+  @override
+  def save(self, base_path: str) -> None:
+    assert self._embeddings is not None and self._key_to_index is not None, (
+      'The vector store has no embeddings. Call load() or add() first.')
+    np.save(base_path + _EMBEDDINGS_SUFFIX, self._embeddings, allow_pickle=False)
+    self._key_to_index.to_pickle(base_path + _LOOKUP_SUFFIX)
+
+  @override
+  def load(self, base_path: str) -> None:
+    self._embeddings = np.load(base_path + _EMBEDDINGS_SUFFIX, allow_pickle=False)
+    self._key_to_index = pd.read_pickle(base_path + _LOOKUP_SUFFIX)
+
+  @override
+  def add(self, keys: list[VectorKey], embeddings: np.ndarray) -> None:
+    if self._embeddings or self._key_to_index:
+      raise ValueError('Embeddings already exist in this store. Upsert is not yet supported.')
+
+    if len(keys) != embeddings.shape[0]:
+      raise ValueError(
+        f'Length of keys ({len(keys)}) does not match number of embeddings {embeddings.shape[0]}.')
+
+    # Cast to float32 since dot product with float32 is 40-50x faster than float16 and 2.5x faster
+    # than float64.
+    self._embeddings = embeddings.astype(np.float32)
+    row_indices = np.arange(len(embeddings), dtype=np.uint32)
+    self._key_to_index = pd.Series(row_indices, index=keys, dtype=np.uint32)
+
+  @override
+  def get(self, keys: Optional[Iterable[VectorKey]] = None) -> np.ndarray:
+    assert self._embeddings is not None and self._key_to_index is not None, (
+      'The vector store has no embeddings. Call load() or add() first.')
+    if not keys:
+      return self._embeddings
+    locs = self._key_to_index.loc[cast(list[str], keys)]
+    return self._embeddings.take(locs, axis=0)
+
+  @override
+  def topk(self,
+           query: np.ndarray,
+           k: int,
+           keys: Optional[Iterable[VectorKey]] = None) -> list[tuple[VectorKey, float]]:
+    assert self._embeddings is not None and self._key_to_index is not None, (
+      'The vector store has no embeddings. Call load() or add() first.')
+    if keys is not None:
+      row_indices = self._key_to_index.loc[cast(list[str], keys)]
+      embeddings = self._embeddings.take(row_indices, axis=0)
+      keys = list(keys)
+    else:
+      keys, embeddings = cast(list[VectorKey], self._key_to_index.index.tolist()), self._embeddings
+
+    query = query.astype(embeddings.dtype)
+    similarities: np.ndarray = np.dot(embeddings, query).reshape(-1)
+    k = min(k, len(similarities))
+
+    # We do a partition + sort only top K to save time: O(n + klogk) instead of O(nlogn).
+    indices = np.argpartition(similarities, -k)[-k:]
+    # Indices sorted by value from largest to smallest.
+    indices = indices[np.argsort(similarities[indices])][::-1]
+
+    topk_similarities = similarities[indices]
+    topk_keys = [keys[idx] for idx in indices]
+    return list(zip(topk_keys, topk_similarities))