Repository: pepkit/pipestat (language: python)

Issue:
pipestat summarize: title of the html page is "Looper: None Summary"

pipestat summarize: title of the html page is "Looper: None Summary"

pipestat summarize: log files are not gathered when making a portable report
- log files are not gathered properly when making a portable version of the report


Discussion / hints:

Fix patch:
diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml
index 148f5701..a910e5a3 100644
--- a/.github/workflows/python-publish.yml
+++ b/.github/workflows/python-publish.yml
@@ -12,12 +12,11 @@ jobs:
     name: upload release to PyPI
     runs-on: ubuntu-latest
     permissions:
-      # IMPORTANT: this permission is mandatory for trusted publishing
-      id-token: write
+      id-token: write  # IMPORTANT: this permission is mandatory for trusted publishing
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v5
       with:
         python-version: '3.x'
     - name: Install dependencies
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 05d4cd4b..5dc7c139 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -9,13 +9,14 @@ repos:
       - id: trailing-whitespace
       - id: check-ast
 
-  - repo: https://github.com/PyCQA/isort
-    rev: 5.9.1
-    hooks:
-      - id: isort
-        args: ["--profile", "black"]
+#  - repo: https://github.com/PyCQA/isort
+#    rev: 5.9.1
+#    hooks:
+#      - id: isort
+#        args: ["--profile", "black"]
 
   - repo: https://github.com/psf/black
     rev: 21.6b0
     hooks:
       - id: black
+        args : ["--line-length", "99"]
diff --git a/.readthedocs.yaml b/.readthedocs.yaml
deleted file mode 100644
index 627716f9..00000000
--- a/.readthedocs.yaml
+++ /dev/null
@@ -1,19 +0,0 @@
-# Read the Docs configuration file for MkDocs projects
-# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
-
-# Required
-version: 2
-
-# Set the version of Python and other tools you might need
-build:
-  os: ubuntu-22.04
-  tools:
-    python: "3.10"
-
-mkdocs:
-  configuration: mkdocs.yml
-
-# Optionally declare the Python requirements required to build your docs
-python:
-  install:
-  - requirements: requirements/requirements-doc.txt
\ No newline at end of file
diff --git a/README.md b/README.md
index 44e81610..a404db6f 100644
--- a/README.md
+++ b/README.md
@@ -9,20 +9,33 @@
 
 Pipestat standardizes reporting of pipeline results. It provides 1) a standard specification for how pipeline outputs should be stored; and 2) an implementation to easily write results to that format from within Python or from the command line. A pipeline author defines all the outputs produced by a pipeline by writing a JSON-schema. The pipeline then uses pipestat to report pipeline outputs as the pipeline runs, either via the Python API or command line interface. The user configures results to be stored either in a [YAML-formatted file](https://yaml.org/spec/1.2/spec.html) or a [PostgreSQL database](https://www.postgresql.org/).
 
-See [Pipestat documentation](https://pipestat.databio.org) for complete details.
+See [Pipestat documentation](https://pep.databio.org/pipestat/) for complete details.
 
 
 ## Developer tests
 
-First you need a local demo instance of posgres running to test the database back-end. you can get one using docker matching the included config file like this:
+###  Optional Dependencies
 
-```
-docker run --rm -it -e POSTGRES_USER=postgres -e POSTGRES_PASSWORD=pipestat-password -e POSTGRES_DB=pipestat-test -p 5432:5432 postgres
-```
+Note: to run the pytest suite locally, you will need to install the related requirements:
+
+```bash
+cd pipestat
 
-Then, run tests:
+pip install -r requirements/requirements-test.txt
 
 ```
-pytest
+
+### Database Backend Configuration for Tests
+
+Many of the tests require a postgres database to be set up otherwise many of the tests will skip.
+
+We recommend using docker:
+```bash
+docker run --rm -it --name pipestat_test_db \
+    -e POSTGRES_USER=postgres \
+    -e POSTGRES_PASSWORD=pipestat-password \
+    -e POSTGRES_DB=pipestat-test \
+    -p 5432:5432 \
+    postgres
 ```
 
diff --git a/docs/api_docs.md b/docs/api_docs.md
deleted file mode 100644
index 839c428c..00000000
--- a/docs/api_docs.md
+++ /dev/null
@@ -1,1027 +0,0 @@
-Final targets: PipestatBoss, PipestatError, PipestatManager, ProjectPipestatManager, SamplePipestatManager, __version__
-<script>
-document.addEventListener('DOMContentLoaded', (event) => {
-  document.querySelectorAll('h3 code').forEach((block) => {
-    hljs.highlightBlock(block);
-  });
-});
-</script>
-
-<style>
-h3 .content { 
-    padding-left: 22px;
-    text-indent: -15px;
- }
-h3 .hljs .content {
-    padding-left: 20px;
-    margin-left: 0px;
-    text-indent: -15px;
-    martin-bottom: 0px;
-}
-h4 .content, table .content, p .content, li .content { margin-left: 30px; }
-h4 .content { 
-    font-style: italic;
-    font-size: 1em;
-    margin-bottom: 0px;
-}
-
-</style>
-
-
-# Package `pipestat` Documentation
-
-## <a name="PipestatError"></a> Class `PipestatError`
-Base exception type for this package
-
-
-## <a name="SamplePipestatManager"></a> Class `SamplePipestatManager`
-Pipestat standardizes reporting of pipeline results and pipeline status management. It formalizes a way for pipeline developers and downstream tools developers to communicate -- results produced by a pipeline can easily and reliably become an input for downstream analyses. A PipestatManager object exposes an API for interacting with the results and pipeline status and can be backed by either a YAML-formatted file or a database.
-
-
-```python
-def __init__(self, **kwargs)
-```
-
-Initialize the PipestatManager object
-#### Parameters:
-
-- `record_identifier` (`str`):  record identifier to report for. Thiscreates a weak bound to the record, which can be overridden in this object method calls
-- `schema_path` (`str`):  path to the output schema that formalizesthe results structure
-- `results_file_path` (`str`):  YAML file to report into, if file isused as the object back-end
-- `database_only` (`bool`):  whether the reported data should not bestored in the memory, but only in the database
-- `config_file` (`str`):  path to the configuration file
-- `config_dict` (`dict`):   a mapping with the config file content
-- `flag_file_dir` (`str`):  path to directory containing flag files
-- `show_db_logs` (`bool`):  Defaults to False, toggles showing database logs
-- `pipeline_type` (`str`):  "sample" or "project"
-- `pipeline_name` (`str`):  name of the current pipeline, defaults to
-- `result_formatter` (`str`):  function for formatting result
-- `multi_pipelines` (`bool`):  allows for running multiple pipelines for one file backend
-- `output_dir` (`str`):  target directory for report generation via summarize and table generation via table.
-
-
-
-
-```python
-def clear_status(self, *args, **kwargs)
-```
-
-
-
-```python
-def config_path(self)
-```
-
-Config path. None if the config was not provided or if provided as a mapping of the config contents
-#### Returns:
-
-- `str`:  path to the provided config
-
-
-
-
-```python
-def count_records(self, *args, **kwargs)
-```
-
-
-
-```python
-def data(self)
-```
-
-Data object
-#### Returns:
-
-- `yacman.YAMLConfigManager`:  the object that stores the reported data
-
-
-
-
-```python
-def db_url(self)
-```
-
-Database URL, generated based on config credentials
-#### Returns:
-
-- `str`:  database URL
-
-
-#### Raises:
-
-- `PipestatDatabaseError`:  if the object is not backed by a database
-
-
-
-
-```python
-def file(self)
-```
-
-File path that the object is reporting the results into
-#### Returns:
-
-- `str`:  file path that the object is reporting the results into
-
-
-
-
-```python
-def get_status(self, *args, **kwargs)
-```
-
-
-
-```python
-def highlighted_results(self)
-```
-
-Highlighted results
-#### Returns:
-
-- `List[str]`:  a collection of highlighted results
-
-
-
-
-```python
-def initialize_dbbackend(*args, **kwargs)
-```
-
-
-
-```python
-def link(self, *args, **kwargs)
-```
-
-
-
-```python
-def list_recent_results(self, *args, **kwargs)
-```
-
-
-
-```python
-def output_dir(self)
-```
-
-Output directory for report and stats generation
-#### Returns:
-
-- `str`:  path to output_dir
-
-
-
-
-```python
-def pipeline_name(self)
-```
-
-Pipeline name
-#### Returns:
-
-- `str`:  Pipeline name
-
-
-
-
-```python
-def pipeline_type(self)
-```
-
-Pipeline type: "sample" or "project"
-#### Returns:
-
-- `str`:  pipeline type
-
-
-
-
-```python
-def project_name(self)
-```
-
-Project name the object writes the results to
-#### Returns:
-
-- `str`:  project name the object writes the results to
-
-
-
-
-```python
-def record_count(self)
-```
-
-Number of records reported
-#### Returns:
-
-- `int`:  number of records reported
-
-
-
-
-```python
-def record_identifier(self)
-```
-
-Pipeline type: "sample" or "project"
-#### Returns:
-
-- `str`:  pipeline type
-
-
-
-
-```python
-def remove(self, *args, **kwargs)
-```
-
-
-
-```python
-def report(self, *args, **kwargs)
-```
-
-
-
-```python
-def result_schemas(self)
-```
-
-Result schema mappings
-#### Returns:
-
-- `dict`:  schemas that formalize the structure of each resultin a canonical jsonschema way
-
-
-
-
-```python
-def retrieve_one(self, *args, **kwargs)
-```
-
-
-
-```python
-def schema(self)
-```
-
-Schema mapping
-#### Returns:
-
-- `ParsedSchema`:  schema object that formalizes the results structure
-
-
-
-
-```python
-def schema_path(self)
-```
-
-Schema path
-#### Returns:
-
-- `str`:  path to the provided schema
-
-
-
-
-```python
-def select_distinct(self, *args, **kwargs)
-```
-
-
-
-```python
-def select_records(self, *args, **kwargs)
-```
-
-
-
-```python
-def set_status(self, *args, **kwargs)
-```
-
-
-
-```python
-def status_schema(self)
-```
-
-Status schema mapping
-#### Returns:
-
-- `dict`:  schema that formalizes the pipeline status structure
-
-
-
-
-```python
-def status_schema_source(self)
-```
-
-Status schema source
-#### Returns:
-
-- `dict`:  source of the schema that formalizesthe pipeline status structure
-
-
-
-
-```python
-def summarize(self, *args, **kwargs)
-```
-
-
-
-```python
-def table(self, *args, **kwargs)
-```
-
-
-
-## <a name="ProjectPipestatManager"></a> Class `ProjectPipestatManager`
-Pipestat standardizes reporting of pipeline results and pipeline status management. It formalizes a way for pipeline developers and downstream tools developers to communicate -- results produced by a pipeline can easily and reliably become an input for downstream analyses. A PipestatManager object exposes an API for interacting with the results and pipeline status and can be backed by either a YAML-formatted file or a database.
-
-
-```python
-def __init__(self, **kwargs)
-```
-
-Initialize the PipestatManager object
-#### Parameters:
-
-- `record_identifier` (`str`):  record identifier to report for. Thiscreates a weak bound to the record, which can be overridden in this object method calls
-- `schema_path` (`str`):  path to the output schema that formalizesthe results structure
-- `results_file_path` (`str`):  YAML file to report into, if file isused as the object back-end
-- `database_only` (`bool`):  whether the reported data should not bestored in the memory, but only in the database
-- `config_file` (`str`):  path to the configuration file
-- `config_dict` (`dict`):   a mapping with the config file content
-- `flag_file_dir` (`str`):  path to directory containing flag files
-- `show_db_logs` (`bool`):  Defaults to False, toggles showing database logs
-- `pipeline_type` (`str`):  "sample" or "project"
-- `pipeline_name` (`str`):  name of the current pipeline, defaults to
-- `result_formatter` (`str`):  function for formatting result
-- `multi_pipelines` (`bool`):  allows for running multiple pipelines for one file backend
-- `output_dir` (`str`):  target directory for report generation via summarize and table generation via table.
-
-
-
-
-```python
-def clear_status(self, *args, **kwargs)
-```
-
-
-
-```python
-def config_path(self)
-```
-
-Config path. None if the config was not provided or if provided as a mapping of the config contents
-#### Returns:
-
-- `str`:  path to the provided config
-
-
-
-
-```python
-def count_records(self, *args, **kwargs)
-```
-
-
-
-```python
-def data(self)
-```
-
-Data object
-#### Returns:
-
-- `yacman.YAMLConfigManager`:  the object that stores the reported data
-
-
-
-
-```python
-def db_url(self)
-```
-
-Database URL, generated based on config credentials
-#### Returns:
-
-- `str`:  database URL
-
-
-#### Raises:
-
-- `PipestatDatabaseError`:  if the object is not backed by a database
-
-
-
-
-```python
-def file(self)
-```
-
-File path that the object is reporting the results into
-#### Returns:
-
-- `str`:  file path that the object is reporting the results into
-
-
-
-
-```python
-def get_status(self, *args, **kwargs)
-```
-
-
-
-```python
-def highlighted_results(self)
-```
-
-Highlighted results
-#### Returns:
-
-- `List[str]`:  a collection of highlighted results
-
-
-
-
-```python
-def initialize_dbbackend(*args, **kwargs)
-```
-
-
-
-```python
-def link(self, *args, **kwargs)
-```
-
-
-
-```python
-def list_recent_results(self, *args, **kwargs)
-```
-
-
-
-```python
-def output_dir(self)
-```
-
-Output directory for report and stats generation
-#### Returns:
-
-- `str`:  path to output_dir
-
-
-
-
-```python
-def pipeline_name(self)
-```
-
-Pipeline name
-#### Returns:
-
-- `str`:  Pipeline name
-
-
-
-
-```python
-def pipeline_type(self)
-```
-
-Pipeline type: "sample" or "project"
-#### Returns:
-
-- `str`:  pipeline type
-
-
-
-
-```python
-def project_name(self)
-```
-
-Project name the object writes the results to
-#### Returns:
-
-- `str`:  project name the object writes the results to
-
-
-
-
-```python
-def record_count(self)
-```
-
-Number of records reported
-#### Returns:
-
-- `int`:  number of records reported
-
-
-
-
-```python
-def record_identifier(self)
-```
-
-Pipeline type: "sample" or "project"
-#### Returns:
-
-- `str`:  pipeline type
-
-
-
-
-```python
-def remove(self, *args, **kwargs)
-```
-
-
-
-```python
-def report(self, *args, **kwargs)
-```
-
-
-
-```python
-def result_schemas(self)
-```
-
-Result schema mappings
-#### Returns:
-
-- `dict`:  schemas that formalize the structure of each resultin a canonical jsonschema way
-
-
-
-
-```python
-def retrieve_one(self, *args, **kwargs)
-```
-
-
-
-```python
-def schema(self)
-```
-
-Schema mapping
-#### Returns:
-
-- `ParsedSchema`:  schema object that formalizes the results structure
-
-
-
-
-```python
-def schema_path(self)
-```
-
-Schema path
-#### Returns:
-
-- `str`:  path to the provided schema
-
-
-
-
-```python
-def select_distinct(self, *args, **kwargs)
-```
-
-
-
-```python
-def select_records(self, *args, **kwargs)
-```
-
-
-
-```python
-def set_status(self, *args, **kwargs)
-```
-
-
-
-```python
-def status_schema(self)
-```
-
-Status schema mapping
-#### Returns:
-
-- `dict`:  schema that formalizes the pipeline status structure
-
-
-
-
-```python
-def status_schema_source(self)
-```
-
-Status schema source
-#### Returns:
-
-- `dict`:  source of the schema that formalizesthe pipeline status structure
-
-
-
-
-```python
-def summarize(self, *args, **kwargs)
-```
-
-
-
-```python
-def table(self, *args, **kwargs)
-```
-
-
-
-## <a name="PipestatBoss"></a> Class `PipestatBoss`
-PipestatBoss simply holds Sample or Project Managers that are child classes of PipestatManager. :param list[str] pipeline_list: list that holds pipeline types, e.g. ['sample','project'] :param str record_identifier: record identifier to report for. This creates a weak bound to the record, which can be overridden in this object method calls :param str schema_path: path to the output schema that formalizes the results structure :param str results_file_path: YAML file to report into, if file is used as the object back-end :param bool database_only: whether the reported data should not be stored in the memory, but only in the database :param str | dict config: path to the configuration file or a mapping with the config file content :param str flag_file_dir: path to directory containing flag files :param bool show_db_logs: Defaults to False, toggles showing database logs :param str pipeline_type: "sample" or "project" :param str result_formatter: function for formatting result :param bool multi_pipelines: allows for running multiple pipelines for one file backend :param str output_dir: target directory for report generation via summarize and table generation via table.
-
-
-```python
-def __init__(self, pipeline_list: Optional[list]=None, **kwargs)
-```
-
-Initialize self.  See help(type(self)) for accurate signature.
-
-
-
-## <a name="PipestatManager"></a> Class `PipestatManager`
-Pipestat standardizes reporting of pipeline results and pipeline status management. It formalizes a way for pipeline developers and downstream tools developers to communicate -- results produced by a pipeline can easily and reliably become an input for downstream analyses. A PipestatManager object exposes an API for interacting with the results and pipeline status and can be backed by either a YAML-formatted file or a database.
-
-
-```python
-def __init__(self, project_name: Optional[str]=None, record_identifier: Optional[str]=None, schema_path: Optional[str]=None, results_file_path: Optional[str]=None, database_only: Optional[bool]=True, config_file: Optional[str]=None, config_dict: Optional[dict]=None, flag_file_dir: Optional[str]=None, show_db_logs: bool=False, pipeline_type: Optional[str]=None, pipeline_name: Optional[str]='default_pipeline_name', result_formatter: staticmethod=<function default_formatter at 0x7f876c474040>, multi_pipelines: bool=False, output_dir: Optional[str]=None)
-```
-
-Initialize the PipestatManager object
-#### Parameters:
-
-- `record_identifier` (`str`):  record identifier to report for. Thiscreates a weak bound to the record, which can be overridden in this object method calls
-- `schema_path` (`str`):  path to the output schema that formalizesthe results structure
-- `results_file_path` (`str`):  YAML file to report into, if file isused as the object back-end
-- `database_only` (`bool`):  whether the reported data should not bestored in the memory, but only in the database
-- `config_file` (`str`):  path to the configuration file
-- `config_dict` (`dict`):   a mapping with the config file content
-- `flag_file_dir` (`str`):  path to directory containing flag files
-- `show_db_logs` (`bool`):  Defaults to False, toggles showing database logs
-- `pipeline_type` (`str`):  "sample" or "project"
-- `pipeline_name` (`str`):  name of the current pipeline, defaults to
-- `result_formatter` (`str`):  function for formatting result
-- `multi_pipelines` (`bool`):  allows for running multiple pipelines for one file backend
-- `output_dir` (`str`):  target directory for report generation via summarize and table generation via table.
-
-
-
-
-```python
-def check_multi_results(self)
-```
-
-
-
-```python
-def clear_status(self, *args, **kwargs)
-```
-
-
-
-```python
-def config_path(self)
-```
-
-Config path. None if the config was not provided or if provided as a mapping of the config contents
-#### Returns:
-
-- `str`:  path to the provided config
-
-
-
-
-```python
-def count_records(self, *args, **kwargs)
-```
-
-
-
-```python
-def data(self)
-```
-
-Data object
-#### Returns:
-
-- `yacman.YAMLConfigManager`:  the object that stores the reported data
-
-
-
-
-```python
-def db_url(self)
-```
-
-Database URL, generated based on config credentials
-#### Returns:
-
-- `str`:  database URL
-
-
-#### Raises:
-
-- `PipestatDatabaseError`:  if the object is not backed by a database
-
-
-
-
-```python
-def file(self)
-```
-
-File path that the object is reporting the results into
-#### Returns:
-
-- `str`:  file path that the object is reporting the results into
-
-
-
-
-```python
-def get_status(self, *args, **kwargs)
-```
-
-
-
-```python
-def highlighted_results(self)
-```
-
-Highlighted results
-#### Returns:
-
-- `List[str]`:  a collection of highlighted results
-
-
-
-
-```python
-def initialize_dbbackend(*args, **kwargs)
-```
-
-
-
-```python
-def initialize_filebackend(self, record_identifier, results_file_path, flag_file_dir)
-```
-
-
-
-```python
-def link(self, *args, **kwargs)
-```
-
-
-
-```python
-def list_recent_results(self, *args, **kwargs)
-```
-
-
-
-```python
-def output_dir(self)
-```
-
-Output directory for report and stats generation
-#### Returns:
-
-- `str`:  path to output_dir
-
-
-
-
-```python
-def pipeline_name(self)
-```
-
-Pipeline name
-#### Returns:
-
-- `str`:  Pipeline name
-
-
-
-
-```python
-def pipeline_type(self)
-```
-
-Pipeline type: "sample" or "project"
-#### Returns:
-
-- `str`:  pipeline type
-
-
-
-
-```python
-def process_schema(self, schema_path)
-```
-
-
-
-```python
-def project_name(self)
-```
-
-Project name the object writes the results to
-#### Returns:
-
-- `str`:  project name the object writes the results to
-
-
-
-
-```python
-def record_count(self)
-```
-
-Number of records reported
-#### Returns:
-
-- `int`:  number of records reported
-
-
-
-
-```python
-def record_identifier(self)
-```
-
-Pipeline type: "sample" or "project"
-#### Returns:
-
-- `str`:  pipeline type
-
-
-
-
-```python
-def remove(self, *args, **kwargs)
-```
-
-
-
-```python
-def report(self, *args, **kwargs)
-```
-
-
-
-```python
-def resolve_results_file_path(self, results_file_path)
-```
-
-Replace {record_identifier} in results_file_path if it exists.
-#### Parameters:
-
-- `results_file_path` (`str`):  YAML file to report into, if file isused as the object back-end
-
-
-
-
-```python
-def result_schemas(self)
-```
-
-Result schema mappings
-#### Returns:
-
-- `dict`:  schemas that formalize the structure of each resultin a canonical jsonschema way
-
-
-
-
-```python
-def retrieve_many(self, record_identifiers: List[str], result_identifier: Optional[str]=None) -> Union[Any, Dict[str, Any]]
-```
-
-
-#### Parameters:
-
-- `record_identifiers` (``):  list of record identifiers
-- `result_identifier` (`str`):  single record_identifier
-
-
-#### Returns:
-
-- ``:  a mapping with filteredresults reported for the record
-
-
-
-
-```python
-def retrieve_one(self, *args, **kwargs)
-```
-
-
-
-```python
-def schema(self)
-```
-
-Schema mapping
-#### Returns:
-
-- `ParsedSchema`:  schema object that formalizes the results structure
-
-
-
-
-```python
-def schema_path(self)
-```
-
-Schema path
-#### Returns:
-
-- `str`:  path to the provided schema
-
-
-
-
-```python
-def select_distinct(self, *args, **kwargs)
-```
-
-
-
-```python
-def select_records(self, *args, **kwargs)
-```
-
-
-
-```python
-def set_status(self, *args, **kwargs)
-```
-
-
-
-```python
-def status_schema(self)
-```
-
-Status schema mapping
-#### Returns:
-
-- `dict`:  schema that formalizes the pipeline status structure
-
-
-
-
-```python
-def status_schema_source(self)
-```
-
-Status schema source
-#### Returns:
-
-- `dict`:  source of the schema that formalizesthe pipeline status structure
-
-
-
-
-```python
-def summarize(self, *args, **kwargs)
-```
-
-
-
-```python
-def table(self, *args, **kwargs)
-```
-
-
-
-
-
-
-*Version Information: `pipestat` v0.8.0, generated by `lucidoc` v0.4.4*
diff --git a/docs/autodoc_build/pipestat.md b/docs/autodoc_build/pipestat.md
deleted file mode 100644
index 8defda7a..00000000
--- a/docs/autodoc_build/pipestat.md
+++ /dev/null
@@ -1,531 +0,0 @@
-<script>
-document.addEventListener('DOMContentLoaded', (event) => {
-  document.querySelectorAll('h3 code').forEach((block) => {
-    hljs.highlightBlock(block);
-  });
-});
-</script>
-
-<style>
-h3 .content { 
-    padding-left: 22px;
-    text-indent: -15px;
- }
-h3 .hljs .content {
-    padding-left: 20px;
-    margin-left: 0px;
-    text-indent: -15px;
-    martin-bottom: 0px;
-}
-h4 .content, table .content, p .content, li .content { margin-left: 30px; }
-h4 .content { 
-    font-style: italic;
-    font-size: 1em;
-    margin-bottom: 0px;
-}
-
-</style>
-
-
-# Package `pipestat` Documentation
-
-## <a name="PipestatError"></a> Class `PipestatError`
-Base exception type for this package
-
-
-## <a name="PipestatManager"></a> Class `PipestatManager`
-Pipestat standardizes reporting of pipeline results and pipeline status management. It formalizes a way for pipeline developers and downstream tools developers to communicate -- results produced by a pipeline can easily and reliably become an input for downstream analyses. A PipestatManager object exposes an API for interacting with the results and pipeline status and can be backed by either a YAML-formatted file or a database.
-
-
-```python
-def __init__(self, record_identifier: Optional[str] = None, schema_path: Optional[str] = None, results_file_path: Optional[str] = None, database_only: Optional[bool] = True, config: Union[str, dict, NoneType] = None, flag_file_dir: Optional[str] = None, show_db_logs: bool = False, project_level: Optional[bool] = False)
-```
-
-Initialize the object
-#### Parameters:
-
-- `record_identifier` (`str`):  record identifier to report for. Thiscreates a weak bound to the record, which can be overridden in this object method calls
-- `schema_path` (`str`):  path to the output schema that formalizesthe results structure
-- `results_file_path` (`str`):  YAML file to report into, if file isused as the object back-end
-- `database_only` (`bool`):  whether the reported data should not bestored in the memory, but only in the database
-- `config` (`str | dict`):  path to the configuration file or a mappingwith the config file content
-
-
-
-
-```python
-def assert_results_defined(self, results: List[str]) -> None
-```
-
-Assert provided list of results is defined in the schema
-#### Parameters:
-
-- `results` (`List[str]`):  list of results tocheck for existence in the schema
-
-
-#### Raises:
-
-- `SchemaError`:  if any of the results is not defined in the schema
-
-
-
-
-```python
-def check_record_exists(self, record_identifier: str, table_name: str) -> bool
-```
-
-Check if the specified record exists in the table
-#### Parameters:
-
-- `record_identifier` (`str`):  record to check for
-- `table_name` (`str`):  table name to check
-
-
-#### Returns:
-
-- `bool`:  whether the record exists in the table
-
-
-
-
-```python
-def check_result_exists(self, result_identifier: str, record_identifier: str = None) -> bool
-```
-
-Check if the result has been reported
-#### Parameters:
-
-- `record_identifier` (`str`):  unique identifier of the record
-- `result_identifier` (`str`):  name of the result to check
-
-
-#### Returns:
-
-- `bool`:  whether the specified result has been reported for theindicated record in current namespace
-
-
-
-
-```python
-def check_which_results_exist(self, results: List[str], rid: Optional[str] = None, table_name: Optional[str] = None) -> List[str]
-```
-
-Check which results have been reported
-#### Parameters:
-
-- `results` (`List[str]`):  names of the results to check
-- `rid` (`str`):  unique identifier of the record
-- `table_name` (`str`):  name of the table for which to check results
-
-
-#### Returns:
-
-- `List[str]`:  names of results which exist
-
-
-
-
-```python
-def clear_status(self, record_identifier: str = None, flag_names: List[str] = None) -> List[Optional[str]]
-```
-
-Remove status flags
-#### Parameters:
-
-- `record_identifier` (`str`):  name of the record to remove flags for
-- `flag_names` (`Iterable[str]`):  Names of flags to remove, optional; ifunspecified, all schema-defined flag names will be used.
-
-
-#### Returns:
-
-- `List[str]`:  Collection of names of flags removed
-
-
-
-
-```python
-def config_path(self)
-```
-
-Config path. None if the config was not provided or if provided as a mapping of the config contents
-#### Returns:
-
-- `str`:  path to the provided config
-
-
-
-
-```python
-def data(self)
-```
-
-Data object
-#### Returns:
-
-- `yacman.YAMLConfigManager`:  the object that stores the reported data
-
-
-
-
-```python
-def db_column_kwargs_by_result(self)
-```
-
-Database column key word arguments for every result, sourced from the results schema in the `db_column` section
-#### Returns:
-
-- `Dict[str, Any]`:  key word arguments for every result
-
-
-
-
-```python
-def db_url(self)
-```
-
-Database URL, generated based on config credentials
-#### Returns:
-
-- `str`:  database URL
-
-
-#### Raises:
-
-- `PipestatDatabaseError`:  if the object is not backed by a database
-
-
-
-
-```python
-def file(self)
-```
-
-File path that the object is reporting the results into
-#### Returns:
-
-- `str`:  file path that the object is reporting the results into
-
-
-
-
-```python
-def get_one_record(self, table_name: str, rid: Optional[str] = None)
-```
-
-
-
-```python
-def get_orm(self, table_name: str) -> Any
-```
-
-Get an object relational mapper class
-#### Parameters:
-
-- `table_name` (`str`):  table name to get a class for
-
-
-#### Returns:
-
-- `Any`:  Object relational mapper class
-
-
-
-
-```python
-def get_status(self, record_identifier: str = None) -> Optional[str]
-```
-
-Get the current pipeline status
-#### Returns:
-
-- `str`:  status identifier, like 'running'
-
-
-
-
-```python
-def get_status_flag_path(self, status_identifier: str, record_identifier=None) -> str
-```
-
-Get the path to the status file flag
-#### Parameters:
-
-- `status_identifier` (`str`):  one of the defined status IDs in schema
-- `record_identifier` (`str`):  unique record ID, optional ifspecified in the object constructor
-
-
-#### Returns:
-
-- `str`:  absolute path to the flag file or None if object isbacked by a DB
-
-
-
-
-```python
-def highlighted_results(self)
-```
-
-Highlighted results
-#### Returns:
-
-- `List[str]`:  a collection of highlighted results
-
-
-
-
-```python
-def namespace(self)
-```
-
-Namespace the object writes the results to
-#### Returns:
-
-- `str`:  namespace the object writes the results to
-
-
-
-
-```python
-def record_count(self)
-```
-
-Number of records reported
-#### Returns:
-
-- `int`:  number of records reported
-
-
-
-
-```python
-def record_identifier(self)
-```
-
-Unique identifier of the record
-#### Returns:
-
-- `str`:  unique identifier of the record
-
-
-
-
-```python
-def remove(self, record_identifier: str = None, result_identifier: str = None) -> bool
-```
-
-Remove a result.
-
-If no result ID specified or last result is removed, the entire record
-will be removed.
-#### Parameters:
-
-- `record_identifier` (`str`):  unique identifier of the record
-- `result_identifier` (`str`):  name of the result to be removed or Noneif the record should be removed.
-
-
-#### Returns:
-
-- `bool`:  whether the result has been removed
-
-
-
-
-```python
-def report(self, values: Dict[str, Any], record_identifier: str = None, force_overwrite: bool = False, strict_type: bool = True, return_id: bool = False, project_level: Optional[bool] = None) -> Union[bool, int]
-```
-
-Report a result.
-#### Parameters:
-
-- `values` (`Dict[str, any]`):  dictionary of result-value pairs
-- `record_identifier` (`str`):  unique identifier of the record, valuein 'record_identifier' column to look for to determine if the record already exists
-- `force_overwrite` (`bool`):  whether to overwrite the existing record
-- `strict_type` (`bool`):  whether the type of the reported values shouldremain as is. Pipestat would attempt to convert to the schema-defined one otherwise
-- `return_id` (`bool`):  PostgreSQL IDs of the records that have beenupdated. Not available with results file as backend
-- `project_level` (``):  whether what's being reported pertains to project-level,rather than sample-level, attribute(s)
-
-
-#### Returns:
-
-- `bool | int`:  whether the result has been reported or the ID ofthe updated record in the table, if requested
-
-
-
-
-```python
-def result_schemas(self)
-```
-
-Result schema mappings
-#### Returns:
-
-- `dict`:  schemas that formalize the structure of each resultin a canonical jsonschema way
-
-
-
-
-```python
-def retrieve(self, record_identifier: Optional[str] = None, result_identifier: Optional[str] = None) -> Union[Any, Dict[str, Any]]
-```
-
-Retrieve a result for a record.
-
-If no result ID specified, results for the entire record will
-be returned.
-#### Parameters:
-
-- `record_identifier` (`str`):  unique identifier of the record
-- `result_identifier` (`str`):  name of the result to be retrieved
-
-
-#### Returns:
-
-- `any | Dict[str, any]`:  a single result or a mapping with all theresults reported for the record
-
-
-
-
-```python
-def schema(self)
-```
-
-Schema mapping
-#### Returns:
-
-- `dict`:  schema that formalizes the results structure
-
-
-
-
-```python
-def schema_path(self)
-```
-
-Schema path
-#### Returns:
-
-- `str`:  path to the provided schema
-
-
-
-
-```python
-def select(self, table_name: Optional[str] = None, columns: Optional[List[str]] = None, filter_conditions: Optional[List[Tuple[str, str, Union[str, List[str]]]]] = None, json_filter_conditions: Optional[List[Tuple[str, str, str]]] = None, offset: Optional[int] = None, limit: Optional[int] = None, project_level: Optional[bool] = None) -> List[Any]
-```
-
-Perform a `SELECT` on the table
-#### Parameters:
-
-- `table_name` (`str`):  name of the table to SELECT from
-- `columns` (`List[str]`):  columns to include in the result
-- `filter_conditions` (`[(key,operator,value)]`): - eq for == - lt for < - ge for >= - in for in_ - like for like
-- `json_filter_conditions` (`[(col,key,value)]`):  conditions for JSONB column toquery that include JSON column name, key withing the JSON object in that column and the value to check the identity against. Therefore only '==' is supported in non-nested checks, e.g. [("other", "genome", "hg38")]
-- `offset` (`int`):  skip this number of rows
-- `limit` (`int`):  include this number of rows
-
-
-
-
-```python
-def select_distinct(self, table_name, columns) -> List[Any]
-```
-
-Perform a `SELECT DISTINCT` on given table and column
-#### Parameters:
-
-- `table_name` (`str`):  name of the table to SELECT from
-- `columns` (`List[str]`):  columns to include in the result
-
-
-
-
-```python
-def select_txt(self, columns: Optional[List[str]] = None, filter_templ: Optional[str] = '', filter_params: Optional[Dict[str, Any]] = {}, table_name: Optional[str] = None, offset: Optional[int] = None, limit: Optional[int] = None) -> List[Any]
-```
-
-Execute a query with a textual filter. Returns all results.
-
-To retrieve all table contents, leave the filter arguments out.
-Table name defaults to the namespace
-#### Parameters:
-
-- `filter_templ` (`str`):  filter template with value placeholders,formatted as follows `id<:value and name=:name`
-- `filter_params` (`Dict[str, Any]`):  a mapping keys specified in the `filter_templ`to parameters that are supposed to replace the placeholders
-- `table_name` (`str`):  name of the table to query
-- `offset` (`int`):  skip this number of rows
-- `limit` (`int`):  include this number of rows
-
-
-#### Returns:
-
-- `List[Any]`:  a list of matched records
-
-
-
-
-```python
-def session(self)
-```
-
-Provide a transactional scope around a series of query operations.
-
-
-
-```python
-def set_status(self, status_identifier: str, record_identifier: str = None, project_level: Optional[bool] = None) -> None
-```
-
-Set pipeline run status.
-
-The status identifier needs to match one of identifiers specified in
-the status schema. A basic, ready to use, status schema is shipped with
-this package.
-#### Parameters:
-
-- `status_identifier` (`str`):  status to set, one of statuses definedin the status schema
-- `record_identifier` (`str`):  record identifier to set thepipeline status for
-- `project_level` (`bool`):  whether status is being set for a project-level pipeline, or sample-level
-
-
-
-
-```python
-def status_schema(self)
-```
-
-Status schema mapping
-#### Returns:
-
-- `dict`:  schema that formalizes the pipeline status structure
-
-
-
-
-```python
-def status_schema_source(self)
-```
-
-Status schema source
-#### Returns:
-
-- `dict`:  source of the schema that formalizesthe pipeline status structure
-
-
-
-
-```python
-def validate_schema(self) -> None
-```
-
-Check schema for any possible issues
-#### Raises:
-
-- `SchemaError`:  if any schema format issue is detected
-
-
-
-
-
-
-
-*Version Information: `pipestat` v0.3.1, generated by `lucidoc` v0.4.4*
\ No newline at end of file
diff --git a/docs/changelog.md b/docs/changelog.md
index 780013a3..8783e5d0 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -2,6 +2,15 @@
 
 This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html) and [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) format.
 
+## [0.8.1] - 2024-02-07
+### Changed
+- Readme to reflect docker db configuration for testing. #145
+- added dependency warning when attempting to run pytest suite without optional dependencies. #146
+- Remove most docs in favor of new docs location: https://pep.databio.org/pipestat/
+### Fixed
+- ensure log files are gathered for portable reports, #149
+- Fix minor html report title bugs #151
+
 ## [0.8.0] - 2024-01-25
 ### Added
 - added `portable` flag to pipestat summarize to create a shareable version of the html report.
diff --git a/docs/config.md b/docs/config.md
deleted file mode 100644
index 5748934e..00000000
--- a/docs/config.md
+++ /dev/null
@@ -1,49 +0,0 @@
-# Pipestat configuration file specification
-
-All the relevant pieces of information required to initialize the `PipestatManager` object can be provided to the object constructor or as a command line argument in the form of a YAML-formatted **pipestat configuration file**.
-
-```yaml
-record_identifier: <unique record identifier for either sample or project-level reporting>
-schema_path: <path to the schema>
-results_file_path: <path to results file> # either "results_file_path"
-database: # or DB login credentials
-  name: <database name>
-  user: <user name>
-  password: <user password>
-  host: <database address>
-  port: <database port>
-  dialect: <database type>
-  driver: <python database driver>
-```
-
-If both `results_file_path` and DB login credentials are provided, the YAML results file is given priority.
-
-Any of the settings specified in the configuration file, apart from the database login credentials, can be overwritten with the respectively named arguments in the `PipestatManager` object constructor. Therefore, the configuration file is *required* only if the intended pipestat back-end is a database or if using pipestat in tandem with [Looper](https://looper.databio.org/en/dev/pipestat/).
-
-## Example
-
-For the [PostgreSQL](https://www.postgresql.org/) instance has been started in a container, with the following command:
-
-```console
-docker run -d
-    --name pipestat-postgres \
-    -p 5432:5432 \
-    -e POSTGRES_PASSWORD=b4fd34f^Fshdwede \
-    -e POSTGRES_USER=john \
-    -e POSTGRES_DB=pipestat-test \
-    -v postgres-data:/var/lib/postgresql/data postgres
-```
-
-The configuration file should look like this:
-
-```yaml
-schema_path: /path/to/schema.yaml
-database:
-  name: pipestat-test
-  user: john
-  password: b4fd34f^Fshdwede
-  host: 127.0.0.1
-  port: 5432
-  dialect: postgresql
-  driver: psycopg
-```
diff --git a/docs/configuration.md b/docs/configuration.md
deleted file mode 100644
index 8b11e1a1..00000000
--- a/docs/configuration.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# Pipestat configuration
-
-Pipestat *requires* a few pieces of information to run:
-
-- a **pipeline_name** to write into, usually contained within the schema file (see below).
-- a path to the **schema** file that describes results that can be reported, e.g. `"your/path/sample_output_schema.yaml"`:
-```yaml
-title: An example Pipestat output schema
-description: A pipeline that uses pipestat to report sample and project level results.
-type: object
-properties:
-  pipeline_name: "default_pipeline_name"
-  samples:
-    type: object
-    properties:
-        result_name:
-          type: string
-          description: "ResultName"
-
-```
-- **backend info**: either path to a YAML-formatted file or pipestat config with PostgreSQL database login credentials. Note that the config file can also contain a path to the yaml-formatted results file:
-```yaml
-schema_path: sample_output_schema.yaml
-#The config can contain either a results_file_path (file backend) or a databse connection (database backend)
-# results_file_path takes priority and will create a PipestatManager with a file backend
-results_file_path: results_file.yaml 
-database:
-  dialect: postgresql
-  driver: psycopg
-  name: pipestat-test
-  user: postgres
-  password: pipestat-password
-  host: 127.0.0.1
-  port: 5432
-
-```
-
-Apart from that, there are many other *optional* configuration points that have defaults. Please refer to the [environment variables reference](http://pipestat.databio.org/en/dev/env_vars/) to learn about the the optional configuration options and their meaning.
-
-## Configuration sources
-
-Pipestat configuration can come from 3 sources, with the following priority:
-
-1. `PipestatManager` constructor
-2. Pipestat configuration file
-3. Environment variables
diff --git a/docs/contributing.md b/docs/contributing.md
deleted file mode 100644
index 53145359..00000000
--- a/docs/contributing.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Contributing
-
-We welcome contributions from the community.
-
-# Suggestions and feedback
-
-Please open an issue on the GitHub issue tracker with suggestions, bug reports, or other feedback.
diff --git a/docs/env_vars.md b/docs/env_vars.md
deleted file mode 100644
index e02c75e1..00000000
--- a/docs/env_vars.md
+++ /dev/null
@@ -1,15 +0,0 @@
-# Environment variables in pipestat
-
-Both the command line interface (CLI) and Python API support a collection of environment variables, which can be used to configure pipestat actions.
-
-Here is a list of the supported environment variables:
-
-| Environment variable           | API argument       | Description                                                                                                                  |
-|--------------------------------|--------------------|------------------------------------------------------------------------------------------------------------------------------|
-| **PIPESTAT_RECORD_IDENTIFIER** | record_identifier  | record identifier to report for. This creates a weak bound to the record, which can be overriden in this object method calls |
-| **PIPESTAT_CONFIG**            | config             | path to the configuration file or a mapping with the config file content                                                     |
-| **PIPESTAT_RESULTS_FILE**      | results_file_path  | YAML file to report into, if file is used as the object back-end                                                             |
-| **PIPESTAT_RESULTS_SCHEMA**    | schema_path        | path to the output schema that formalizes the results structure                                                              |
-| **PIPESTAT_STATUS_SCHEMA**     | status_schema_path | path to the status schema that formalizes the status flags structure                                                         |
-| **PIPESTAT_TYPE**              | pipeline_type      | sample or project-level PipestatManager                                                                                      |
-
diff --git a/docs/install.md b/docs/install.md
deleted file mode 100644
index 3bcb6d8e..00000000
--- a/docs/install.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# Installing pipestat
-
-Install pipestat from [GitHub releases](https://github.com/pepkit/pipestat/releases) or from PyPI with `pip`:
-
-- `pip install --user pipestat`: install into user space.
-- `pip install --user --upgrade pipestat`: update in user space.
-- `pip install pipestat`: install into an active virtual environment.
-- `pip install --upgrade pipestat`: update in virtual environment.
-
-See if your installation worked by calling `pipestat -h` on the command line. If the `pipestat` executable is not in your `$PATH`, append this to your `.bashrc` or `.profile` (or `.bash_profile` on macOS):
-
-Note: with version 0.6.0, Pipestat installs with minimum dependencies to report _only_ using the YAML-formatted backend (FileBackend). If desired, the user can install additional functionality:
-database dependencies:  `pip install pipestat['dbbackend']`
-pipestat reader: `pip install pipestat['pipestatreader']`
-
-```console
-export PATH=~/.local/bin:$PATH
-```
diff --git a/docs/pipestat_specification.md b/docs/pipestat_specification.md
deleted file mode 100644
index d041cdb2..00000000
--- a/docs/pipestat_specification.md
+++ /dev/null
@@ -1,297 +0,0 @@
-<h1>Pipestat specification</h1>
-
-[TOC]
-
-# Introduction
-
-Pipelines, or workflows, are made from a set of commands that process input data and produce results. These results may take many forms, such as simple statistics, string variables, images, or processed data files. How do pipelines structure the results they produce? There is no standard structure for results, so usually, it's done differently for each pipeline. This restricts the portability of the outputs of pipelines, and makes it difficult to write software that can process results from a variety of different pipelines. As a result, each pipeline author usually writes dedicated report functions for each pipeline.
-
-Pipestat provides a formal specification for how a pipeline should structure its results. Therefore, any pipeline that follows the pipestat specification will record results in the same way. This makes it possible to build generic report software that can work with any pipestat-compatible pipeline, offloading the task of making pretty result reports to generic tools.
-
-This document outlines the specification for pipestat results. If your pipeline stores results like this, then downstream tools that read pipestat results will be able to build nice summaries of your pipeline runs automatically. To write results according to this specification, you can use the reference implementation (the `pipestat` python package), or you can simply write your results to this specification using whatever system you like.
-
-# Terminology
-
-- *result*: An element produced by a pipeline. Results have defined data types, described herein.
-- *result identifier*. The name of a result, such as `aligned_read_count` or `duplication_rate`.
-- *value*. The actual data for an output result for a given record.
-- *namespace*: A way to group results that belong together. In the api, this is referenced via `pipeline_name`. This is typically an identifier for a particular pipeline, like `rnaseq-pipeline`. All results from this pipeline will share this namespace.
-- *record identifier*. An identifier for a particular pipeline run, such as a sample name.
-- *pipestat specification*: the way to structure a set of results stored from one or more pipeline runs.
-- *backend*. The technology underlying the result storage, which can be either a simple file or a database.
-
-# Data types
-
-Each *result* reported by a pipeline must have a specified data type. Pipestat is built on jsonschema types, so the jsonschema documentation outlines the [basic available types](https://cswr.github.io/JsonSchema/spec/basic_types/). These types are:
-
-- string
-- number
-- integer
-- boolean
-- null
-
-Importantly, pipestat extends the jsonschema vocabulary by adding two additional types, which are common results of a pipeline: `image` and `file`. These types require reporting objects with the following attributes:
-
-- `file`:
-    - `path`: path to the reported file
-    - `title`: human readable description of the file
-- `image`:
-    - `path`: path to the reported image, usually PDF
-    - `thumbnail`: path to the reported thumbnail, usually PNG or JPEG
-    - `title`: human readable description of the image
-
-# Pipestat output schema
-
-Each pipestat-compatible pipeline must define a *pipestat output schema*. The pipestat schema is where the pipeline author describes the results produced by the pipeline. The pipestat schema specifies:
-
-1. The result identifiers; that is, the immutable names of all the results reported by this pipeline.
-2. The data types associated with each result.
-3. Human-readable description of what each result represents.
-
-As a pipeline developer, your schema defines and describes all the important results to be recorded from your pipeline.
-
-Pipestat uses the schema as a base for creating a collection of self-contained result-specific [jsonschema schemas](https://json-schema.org/) that are used to **validate** the reported results prior to storing them.
-
-## Pipestat output schema format
-
-The pipestat output schema is a YAML-formatted file. The top level keys are the unique result identifiers. The associated values are jsonschema types. The `type` attribute is required. This is an example of a minimal component, specifying only an identifier, and its type:
-
-```yaml
-result_identifier:
-  type: <type>
-```
-
-Here, `result_identifier` can be whatever name you want to use to identify this result. Here's a simple schema example that showcases most of the supported types:
-
-```yaml
-title: Example Pipestat Output Schema
-description: A pipeline that uses pipestat to report sample level results.
-type: object
-properties:
-  pipeline_name: "default_pipeline_name"
-  samples:
-    type: object
-    properties: # result identifiers are properties of the samples object
-      number_of_things:
-        type: integer
-        description: "Number of things"
-      percentage_of_things:
-        type: number
-        description: "Percentage of things"
-      name_of_something:
-        type: string
-        description: "Name of something"
-      switch_value:
-        type: boolean
-        description: "Is the switch on or off"
-```
-
-Here's a more complex schema example that showcases some of the more advanced jsonschema features:
-
-```yaml
-title: An example Pipestat output schema
-description: A pipeline that uses pipestat to report sample and project level results.
-type: object
-properties:
-  pipeline_name: "default_pipeline_name"
-  samples:
-    type: object
-    properties:
-      number_of_things:
-        type: integer
-        description: "Number of things"
-      percentage_of_things:
-        type: number
-        description: "Percentage of things"
-      name_of_something:
-        type: string
-        description: "Name of something"
-      switch_value:
-        type: boolean
-        description: "Is the switch on or off"
-      md5sum:
-        type: string
-        description: "MD5SUM of an object"
-        highlight: true
-      collection_of_images:
-        description: "This store collection of values or objects"
-        type: array
-        items:
-          properties:
-              prop1:
-                description: "This is an example file"
-                $ref: "#/$defs/file"
-      output_file_in_object:
-        type: object
-        properties:
-          prop1:
-            description: "This is an example file"
-            $ref: "#/$defs/file"
-          prop2:
-            description: "This is an example image"
-            $ref: "#/$defs/image"
-        description: "Object output"
-      output_file_in_object_nested:
-        type: object
-        description: First Level
-        properties:
-          prop1:
-            type: object
-            description: Second Level
-            properties:
-              prop2:
-                type: integer
-                description: Third Level
-      output_file:
-        $ref: "#/$defs/file"
-        description: "This a path to the output file"
-      output_image:
-        $ref: "#/$defs/image"
-        description: "This a path to the output image"
-$defs:
-  image:
-    type: object
-    object_type: image
-    properties:
-      path:
-        type: string
-      thumbnail_path:
-        type: string
-      title:
-        type: string
-    required:
-      - path
-      - thumbnail_path
-      - title
-  file:
-    type: object
-    object_type: file
-    properties:
-      path:
-        type: string
-      title:
-        type: string
-    required:
-      - path
-      - title
-
-```
-
-## Results highlighting
-
-The pipestat specification allows to highlight results by adding `highlight: true` attribute under result identifier in the schema file. In the example below the `log_file` result will be highlighted.
-
-```yaml
-number_of_things:
-  type: integer
-  description: "Number of things"
-percentage_of_things:
-  type: number
-  description: "Percentage of things"
-log_file:
-  type: file
-  descripton: "Path to the log file"
-  highlight: true
-```
-
-The highlighted results can be later retrieved by pipestat clients via `PipestatManager.highlighted_results` property, which simply returns a list of result identifiers.
-
-## Add indexing to a Result (database backend only)
-If you would like to index a specific result, you can add `index: True` to the result:
-
-```yaml
-title: An example Pipestat output schema
-description: A pipeline that uses pipestat to report sample and project level results.
-type: object
-properties:
-  pipeline_name: "default_pipeline_name"
-  samples:
-    type: object
-    properties:
-      number_of_things:
-        type: integer
-        description: "Number of things"
-        index: True
-```
-
-# Status schema
-
-Apart from results reporting pipestat provides a robust pipeline status management system, which can be used to report pipeline status from within the pipeline and monitor pipeline's status in other software. Status schema file defines the possible pipeline status identifiers and provides other metadata, like `description` or `color` for display purposes.
-
-Here's an example of the pipestat status schema, which at the same time is the default status schema shipped with the pipestat Python package:
-
-```yaml
-running:
-  description: "the pipeline is running"
-  color: [30, 144, 255] # dodgerblue
-completed:
-  description: "the pipeline has completed"
-  color: [50, 205, 50] # limegreen
-failed:
-  description: "the pipeline has failed"
-  color: [220, 20, 60] # crimson
-waiting:
-  description: "the pipeline is waiting"
-  color: [240, 230, 140] # khaki
-partial:
-  description: "the pipeline stopped before completion point"
-  color: [169, 169, 169] # darkgray
-```
-
-As depicted above the top-level attributes are the status identifiers. Within each section two attributes are required:
-
-- `description` (`str`) a freeform text exhaustively describing the status code.
-- `color` (`list[int]`) an array of integers of length 3 which specifies the desired color associated with the status in RGB color model.
-
-# Backends
-
-The pipestat specification describes two backend types for storing results: a [YAML-formatted file](https://yaml.org/spec/1.2/spec.html) or a [PostgreSQL database](https://www.postgresql.org/). This flexibility makes pipestat useful for a wide variety of use cases. Some users just need a simple text file for smaller-scale needs, which is convenient and universal, requiring no database infrastructure. For larger-scale systems, a database back-end is necssary. The pipestat specification provides a layer that spans the two possibilities, so that reports can be made in the same way, regardless of which back-end is used in a particular use case.
-
-By using the `pipestat` package to write results, the pipeline author need not be concerned with database connections or dealing with racefree file writing, as these tasks are already implemented. The user who runs the pipeline will simply configure the pipestat backend as required.
-
-Both backends organize the results in a hierarchy which is *always* structured this way:
-
-![Result hierarchy](img/result_hierarchy.svg)
-
-## YAML file
-
-For the YAML file backend, each file represents a namespace. The file always begins with a single top-level key which indicates the namespace. Second-level keys correspond to the record identifiers; third-level keys correspond to result identifiers, which point to the reported values. The values can then be any of the allowed pipestat data types, which include both basic and advanced data types.
-
-```yaml
-my_namespace:
-    record1:
-        my_result: 10
-        my_result1:
-            key: "value1"
-    record2:
-        my_result: 3
-        my_result1:
-            key: "value2"
-```
-
-A more concrete example would be:
-
-```yaml
-rnaseq-pipe:
-    patient1:
-        duplicate_rate: 10
-        genomic_distribution:
-            promoter: 15
-            enhancer: 85
-    patient2:
-        duplicate_rate: 3
-        genomic_distribution:
-            promoter: 30
-            enhancer: 70
-```
-
-## PostgreSQL database
-
-For the PostgreSQL backend, the name of the database is configurable and defined in the [config file](config.md) in `database.name`. The database is structured like this:
-
-- The namespace corresponds to the name of the table.
-- The record identifier is indicated in the *unique* `record_identifier` column in that table.
-- Each result is specified as a column in the table, with the column name corresponding to the result identifier
-- The values in the cells for a record and result identifier correspond to the actual data values reported for the given result.
-
-![RDB hierarchy](img/db_hierarchy.svg)
diff --git a/docs/usage.md b/docs/usage.md
deleted file mode 100644
index 28227d73..00000000
--- a/docs/usage.md
+++ /dev/null
@@ -1,273 +0,0 @@
-# Usage reference
-
-Pipestat offers a CLI that can be access via the `pipestat` command in the shell. It offers complete control over reporting, inspecting, etc, via a series of subcommands.
-
-Here you can see the command-line usage instructions for the main command and for each subcommand:
-## `pipestat --help`
-```console
-Configure by setting PIPESTAT_CONFIG env var
-version: 0.8.0
-usage: pipestat [-h] [--version] [--silent] [--verbosity V] [--logdev]
-                {report,inspect,remove,retrieve,status,init,summarize,link,serve}
-                ...
-
-pipestat - report pipeline results
-
-positional arguments:
-  {report,inspect,remove,retrieve,status,init,summarize,link,serve}
-    report              Report a result.
-    inspect             Inspect a database.
-    remove              Remove a result.
-    retrieve            Retrieve a result.
-    status              Manage pipeline status.
-    init                Initialize generic config file
-    summarize           Generates HTML Report
-    link                Create symlinks of reported files
-    serve               Initializes pipestatreader API
-
-options:
-  -h, --help            show this help message and exit
-  --version             show program's version number and exit
-  --silent              Silence logging. Overrides verbosity.
-  --verbosity V         Set logging level (1-5 or logging module level name)
-  --logdev              Expand content of logging message format.
-
-Pipestat standardizes reporting of pipeline results and pipeline status
-management. It formalizes a way for pipeline developers and downstream tools
-developers to communicate -- results produced by a pipeline can easily and
-reliably become an input for downstream analyses. A PipestatManager object
-exposes an API for interacting with the results and pipeline status and can be
-backed by either a YAML-formatted file or a database.
-```
-
-## `pipestat report --help`
-```console
-Configure by setting PIPESTAT_CONFIG env var
-usage: pipestat report [-h] [-n N] [-f F] [-c C] [-a] [-s S] [--status-schema ST]
-                       [--flag-dir FD] [-p P] -i I [-r R] -v V [-o] [-t]
-
-Report a result.
-
-options:
-  -h, --help                   show this help message and exit
-  -n N, --project-name N       Name of the pipeline to report result for. If not provided
-                               'PIPESTAT_PROJECT_NAME' env var will be used. Currently not
-                               set
-  -f F, --results-file F       Path to the YAML file where the results will be stored.
-                               This file will be used as pipestat backend and to restore
-                               the reported results across sessions
-  -c C, --config C             Path to the YAML configuration file. If not provided
-                               'PIPESTAT_CONFIG' env var will be used. Currently not set
-  -a, --database-only          Whether the reported data should not be stored in the
-                               memory, only in the database.
-  -s S, --schema S             Path to the schema that defines the results that can be
-                               reported. If not provided 'PIPESTAT_RESULTS_SCHEMA' env var
-                               will be used. Currently not set
-  --status-schema ST           Path to the status schema. Default will be used if not
-                               provided: /home/drc/GITHUB/pipestat/pipestat/venv/lib/pytho
-                               n3.10/site-packages/pipestat/schemas/status_schema.yaml
-  --flag-dir FD                Path to the flag directory in case YAML file is the
-                               pipestat backend.
-  -p P, --pipeline-type P      project or sample level pipeline type.
-  -i I, --result-identifier I  ID of the result to report; needs to be defined in the
-                               schema
-  -r R, --record-identifier R  ID of the record to report the result for. If not provided
-                               'PIPESTAT_RECORD_IDENTIFIER' env var will be used.
-                               Currently not set
-  -v V, --value V              Value of the result to report
-  -o, --overwrite              Whether the result should override existing ones in case of
-                               name clashes
-  -t, --skip-convert           Whether skip result type conversion into the required class
-                               in case it does not meet the schema requirements
-```
-
-## `pipestat inspect --help`
-```console
-Configure by setting PIPESTAT_CONFIG env var
-usage: pipestat inspect [-h] [-n N] [-f F] [-c C] [-a] [-s S] [--status-schema ST]
-                        [--flag-dir FD] [-p P] [-d]
-
-Inspect a database.
-
-options:
-  -h, --help               show this help message and exit
-  -n N, --project-name N   Name of the pipeline to report result for. If not provided
-                           'PIPESTAT_PROJECT_NAME' env var will be used. Currently not set
-  -f F, --results-file F   Path to the YAML file where the results will be stored. This
-                           file will be used as pipestat backend and to restore the
-                           reported results across sessions
-  -c C, --config C         Path to the YAML configuration file. If not provided
-                           'PIPESTAT_CONFIG' env var will be used. Currently not set
-  -a, --database-only      Whether the reported data should not be stored in the memory,
-                           only in the database.
-  -s S, --schema S         Path to the schema that defines the results that can be
-                           reported. If not provided 'PIPESTAT_RESULTS_SCHEMA' env var
-                           will be used. Currently not set
-  --status-schema ST       Path to the status schema. Default will be used if not
-                           provided:
-                           /home/drc/GITHUB/pipestat/pipestat/venv/lib/python3.10/site-
-                           packages/pipestat/schemas/status_schema.yaml
-  --flag-dir FD            Path to the flag directory in case YAML file is the pipestat
-                           backend.
-  -p P, --pipeline-type P  project or sample level pipeline type.
-  -d, --data               Whether to display the data
-```
-
-## `pipestat remove --help`
-```console
-Configure by setting PIPESTAT_CONFIG env var
-usage: pipestat remove [-h] [-n N] [-f F] [-c C] [-a] [-s S] [--status-schema ST]
-                       [--flag-dir FD] [-p P] -i I [-r R]
-
-Remove a result.
-
-options:
-  -h, --help                   show this help message and exit
-  -n N, --project-name N       Name of the pipeline to report result for. If not provided
-                               'PIPESTAT_PROJECT_NAME' env var will be used. Currently not
-                               set
-  -f F, --results-file F       Path to the YAML file where the results will be stored.
-                               This file will be used as pipestat backend and to restore
-                               the reported results across sessions
-  -c C, --config C             Path to the YAML configuration file. If not provided
-                               'PIPESTAT_CONFIG' env var will be used. Currently not set
-  -a, --database-only          Whether the reported data should not be stored in the
-                               memory, only in the database.
-  -s S, --schema S             Path to the schema that defines the results that can be
-                               reported. If not provided 'PIPESTAT_RESULTS_SCHEMA' env var
-                               will be used. Currently not set
-  --status-schema ST           Path to the status schema. Default will be used if not
-                               provided: /home/drc/GITHUB/pipestat/pipestat/venv/lib/pytho
-                               n3.10/site-packages/pipestat/schemas/status_schema.yaml
-  --flag-dir FD                Path to the flag directory in case YAML file is the
-                               pipestat backend.
-  -p P, --pipeline-type P      project or sample level pipeline type.
-  -i I, --result-identifier I  ID of the result to report; needs to be defined in the
-                               schema
-  -r R, --record-identifier R  ID of the record to report the result for. If not provided
-                               'PIPESTAT_RECORD_IDENTIFIER' env var will be used.
-                               Currently not set
-```
-
-## `pipestat retrieve --help`
-```console
-Configure by setting PIPESTAT_CONFIG env var
-usage: pipestat retrieve [-h] [-n N] [-f F] [-c C] [-a] [-s S] [--status-schema ST]
-                         [--flag-dir FD] [-p P] [-r R]
-
-Retrieve a result.
-
-options:
-  -h, --help                   show this help message and exit
-  -n N, --project-name N       Name of the pipeline to report result for. If not provided
-                               'PIPESTAT_PROJECT_NAME' env var will be used. Currently not
-                               set
-  -f F, --results-file F       Path to the YAML file where the results will be stored.
-                               This file will be used as pipestat backend and to restore
-                               the reported results across sessions
-  -c C, --config C             Path to the YAML configuration file. If not provided
-                               'PIPESTAT_CONFIG' env var will be used. Currently not set
-  -a, --database-only          Whether the reported data should not be stored in the
-                               memory, only in the database.
-  -s S, --schema S             Path to the schema that defines the results that can be
-                               reported. If not provided 'PIPESTAT_RESULTS_SCHEMA' env var
-                               will be used. Currently not set
-  --status-schema ST           Path to the status schema. Default will be used if not
-                               provided: /home/drc/GITHUB/pipestat/pipestat/venv/lib/pytho
-                               n3.10/site-packages/pipestat/schemas/status_schema.yaml
-  --flag-dir FD                Path to the flag directory in case YAML file is the
-                               pipestat backend.
-  -p P, --pipeline-type P      project or sample level pipeline type.
-  -r R, --record-identifier R  ID of the record to report the result for. If not provided
-                               'PIPESTAT_RECORD_IDENTIFIER' env var will be used.
-                               Currently not set
-```
-
-## `pipestat status --help`
-```console
-Configure by setting PIPESTAT_CONFIG env var
-usage: pipestat status [-h] {set,get} ...
-
-Manage pipeline status.
-
-positional arguments:
-  {set,get}
-    set       Set status.
-    get       Get status.
-
-options:
-  -h, --help  show this help message and exit
-```
-
-## `pipestat status get --help`
-```console
-Configure by setting PIPESTAT_CONFIG env var
-usage: pipestat status get [-h] [-n N] [-f F] [-c C] [-a] [-s S] [--status-schema ST]
-                           [--flag-dir FD] [-r R] [-p P]
-
-Get status.
-
-options:
-  -h, --help                   show this help message and exit
-  -n N, --project-name N       Name of the pipeline to report result for. If not provided
-                               'PIPESTAT_PROJECT_NAME' env var will be used. Currently not
-                               set
-  -f F, --results-file F       Path to the YAML file where the results will be stored.
-                               This file will be used as pipestat backend and to restore
-                               the reported results across sessions
-  -c C, --config C             Path to the YAML configuration file. If not provided
-                               'PIPESTAT_CONFIG' env var will be used. Currently not set
-  -a, --database-only          Whether the reported data should not be stored in the
-                               memory, only in the database.
-  -s S, --schema S             Path to the schema that defines the results that can be
-                               reported. If not provided 'PIPESTAT_RESULTS_SCHEMA' env var
-                               will be used. Currently not set
-  --status-schema ST           Path to the status schema. Default will be used if not
-                               provided: /home/drc/GITHUB/pipestat/pipestat/venv/lib/pytho
-                               n3.10/site-packages/pipestat/schemas/status_schema.yaml
-  --flag-dir FD                Path to the flag directory in case YAML file is the
-                               pipestat backend.
-  -r R, --record-identifier R  ID of the record to report the result for. If not provided
-                               'PIPESTAT_RECORD_IDENTIFIER' env var will be used.
-                               Currently not set
-  -p P, --pipeline-type P      project or sample level pipeline type.
-```
-
-## `pipestat status set --help`
-```console
-Configure by setting PIPESTAT_CONFIG env var
-usage: pipestat status set [-h] [-n N] [-f F] [-c C] [-a] [-s S] [--status-schema ST]
-                           [--flag-dir FD] [-r R] [-p P]
-                           status_identifier
-
-Set status.
-
-positional arguments:
-  status_identifier            Status identifier to set.
-
-options:
-  -h, --help                   show this help message and exit
-  -n N, --project-name N       Name of the pipeline to report result for. If not provided
-                               'PIPESTAT_PROJECT_NAME' env var will be used. Currently not
-                               set
-  -f F, --results-file F       Path to the YAML file where the results will be stored.
-                               This file will be used as pipestat backend and to restore
-                               the reported results across sessions
-  -c C, --config C             Path to the YAML configuration file. If not provided
-                               'PIPESTAT_CONFIG' env var will be used. Currently not set
-  -a, --database-only          Whether the reported data should not be stored in the
-                               memory, only in the database.
-  -s S, --schema S             Path to the schema that defines the results that can be
-                               reported. If not provided 'PIPESTAT_RESULTS_SCHEMA' env var
-                               will be used. Currently not set
-  --status-schema ST           Path to the status schema. Default will be used if not
-                               provided: /home/drc/GITHUB/pipestat/pipestat/venv/lib/pytho
-                               n3.10/site-packages/pipestat/schemas/status_schema.yaml
-  --flag-dir FD                Path to the flag directory in case YAML file is the
-                               pipestat backend.
-  -r R, --record-identifier R  ID of the record to report the result for. If not provided
-                               'PIPESTAT_RECORD_IDENTIFIER' env var will be used.
-                               Currently not set
-  -p P, --pipeline-type P      project or sample level pipeline type.
-```
-
diff --git a/docs/usage.template b/docs/usage.template
deleted file mode 100644
index abbab4da..00000000
--- a/docs/usage.template
+++ /dev/null
@@ -1,5 +0,0 @@
-# Usage reference
-
-Pipestat offers a CLI that can be access via the `pipestat` command in the shell. It offers complete control over reporting, inspecting, etc, via a series of subcommands.
-
-Here you can see the command-line usage instructions for the main command and for each subcommand:
diff --git a/docs_jupyter/api_quickstart.ipynb b/docs_jupyter/api_quickstart.ipynb
deleted file mode 100644
index bc71d34f..00000000
--- a/docs_jupyter/api_quickstart.ipynb
+++ /dev/null
@@ -1,216 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "52cf5f9c",
-   "metadata": {},
-   "source": [
-    "# Pipestat API Quickstart Guide\n",
-    "\n",
-    "This example is for quickly reporting results to a results.yaml filebackend."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "426c0155",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from pipestat import PipestatManager\n",
-    "\n",
-    "#File Backend requires a results.yaml file\n",
-    "result_file = \"../tests/data/results_docs_example.yaml\"\n",
-    "\n",
-    "#Every pipestat manager requires an output schema to know the format of results\n",
-    "schema_file = \"../tests/data/sample_output_schema.yaml\"\n",
-    "\n",
-    "# With these two files, we can initialize a PipestatManager object and begin reporting results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "3b2f3ad2",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Initialize PipestatBackend\n",
-      "Initialize FileBackend\n"
-     ]
-    }
-   ],
-   "source": [
-    "psm = PipestatManager(results_file_path=result_file, schema_path=schema_file)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "d886a2c9",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "ParsedSchemaDB (default_pipeline_name)\n",
-      " Project Level Data:\n",
-      " Sample Level Data:\n",
-      " -  number_of_things : {'type': 'integer', 'description': 'Number of things'}\n",
-      " -  percentage_of_things : {'type': 'number', 'description': 'Percentage of things'}\n",
-      " -  name_of_something : {'type': 'string', 'description': 'Name of something'}\n",
-      " -  switch_value : {'type': 'boolean', 'description': 'Is the switch on or off'}\n",
-      " -  output_file : {'description': 'This a path to the output file', 'type': 'object', 'object_type': 'file', 'properties': {'path': {'type': 'string'}, 'title': {'type': 'string'}}, 'required': ['path', 'title']}\n",
-      " -  output_image : {'description': 'This a path to the output image', 'type': 'object', 'object_type': 'image', 'properties': {'path': {'type': 'string'}, 'thumbnail_path': {'type': 'string'}, 'title': {'type': 'string'}}, 'required': ['path', 'thumbnail_path', 'title']}\n",
-      " -  md5sum : {'type': 'string', 'description': 'MD5SUM of an object', 'highlight': True}\n",
-      " Status Data:\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Let's look at our output schema. Notice that the schema is only for reporting sample-level results\n",
-    "print(psm.schema)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "1900c74f",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[\"Reported records for 'my_sample_name_1' in 'default_pipeline_name' :\\n - percentage_of_things: 100\",\n",
-       " \"Reported records for 'my_sample_name_1' in 'default_pipeline_name' :\\n - pipestat_created_time: 2023-11-08 09:52:20\",\n",
-       " \"Reported records for 'my_sample_name_1' in 'default_pipeline_name' :\\n - pipestat_modified_time: 2023-11-08 09:52:20\"]"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Let's report a result. The result_identifier (e.g. percentage_of_things) must be in the output schema.\n",
-    "# When reporting a result, a record_identifier must be provided either at the time of reporting \n",
-    "# or upon PipestatManager creation.\n",
-    "\n",
-    "psm.report(record_identifier=\"my_sample_name_1\", values={\"percentage_of_things\": 100})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "id": "7f63b386",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "These results exist for 'my_sample_name_1': percentage_of_things\n",
-      "Overwriting existing results: percentage_of_things\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[\"Reported records for 'my_sample_name_1' in 'default_pipeline_name' :\\n - percentage_of_things: 50\",\n",
-       " \"Reported records for 'my_sample_name_1' in 'default_pipeline_name' :\\n - pipestat_modified_time: 2023-11-08 10:13:18\"]"
-      ]
-     },
-     "execution_count": 25,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Pipestat reports the result as well as a created time and a modified time.\n",
-    "# We can overwrite the modified time by reporting a new result. However, we MUST set the force_overwrite flag.\n",
-    "psm.report(record_identifier=\"my_sample_name_1\", values={\"percentage_of_things\": 50}, force_overwrite=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "id": "330c4447",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "default_pipeline_name:\n",
-       "  project: {}\n",
-       "  sample:\n",
-       "    my_sample_name_1:\n",
-       "      percentage_of_things: 50\n",
-       "      pipestat_created_time: '2023-11-08 09:52:20'\n",
-       "      pipestat_modified_time: '2023-11-08 10:13:18'\n"
-      ]
-     },
-     "execution_count": 26,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Let's look at the reported data\n",
-    "psm.data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "762eec6f",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'percentage_of_things': 50, 'pipestat_created_time': '2023-11-08 09:52:20', 'pipestat_modified_time': '2023-11-08 10:13:18', 'record_identifier': 'my_sample_name_1'}\n"
-     ]
-    }
-   ],
-   "source": [
-    "# You can also retrieve a result:\n",
-    "result = psm.retrieve_one(record_identifier=\"my_sample_name_1\")\n",
-    "print(result)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4eddc225",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/docs_jupyter/build/.gitignore b/docs_jupyter/build/.gitignore
deleted file mode 100644
index d6b7ef32..00000000
--- a/docs_jupyter/build/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-*
-!.gitignore
diff --git a/docs_jupyter/cli.ipynb b/docs_jupyter/cli.ipynb
deleted file mode 100644
index 4ccccc92..00000000
--- a/docs_jupyter/cli.ipynb
+++ /dev/null
@@ -1,529 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Pipestat CLI\n",
-    "\n",
-    "This tutorial demonstrates how to use the pipeline command-line interface (CLI). You should have already installed pipestat. **Before following this tutorial please make sure you're familiar with more information-rich \"Pipestat Python API\" tutorial.** \n",
-    "Also, for the following tutorial, you will need to point to a **sample_output_schema.yaml** in the schema path. An example file can be found here:\n",
-    "\n",
-    "https://github.com/pepkit/pipestat/blob/master/tests/data/sample_output_schema.yaml"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Report results from the command line by calling `pipestat` and passing in all relevant information:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Reported records for 'sample_name' in 'pipeline_name' namespace:\n",
-      " - percentage_of_things: 12\n"
-     ]
-    }
-   ],
-   "source": [
-    "rm ../tests/data/test_results_1.yaml\n",
-    "touch ../tests/data/test_results_1.yaml\n",
-    "pipestat report \\\n",
-    "    --record-identifier sample_name \\\n",
-    "    --result-identifier percentage_of_things \\\n",
-    "    --value 12 \\\n",
-    "    --results-file ../tests/data/test_results_1.yaml \\\n",
-    "    --schema ../tests/data/sample_output_schema.yaml"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "But this is obviously pretty cumbersome, since you have to pass lots of constant information to every call to report a result. So instead, you have an option to set up environment variables for a particular pipeline run:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Prepare environment"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Pipestat environment variables avoid copious repetition of arguments in subsequent `pipestat` calls. Refer to the [Environment variables reference](http://pipestat.databio.org/en/latest/env_vars/) for the complete list of supported environment variables. We will set a few for this tutorial:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "export PIPESTAT_RESULTS_SCHEMA=../tests/data/sample_output_schema.yaml\n",
-    "export PIPESTAT_RECORD_IDENTIFIER=sample1\n",
-    "export PIPESTAT_RESULTS_FILE=`mktemp` # temporary file for results storage"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Before we dive in, let's take a quick glance at the schema. This is the file that describes what sort of results are reported by this pipeline:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "number_of_things:\n",
-      "  type: integer\n",
-      "  description: \"Number of things\"\n",
-      "percentage_of_things:\n",
-      "  type: number\n",
-      "  description: \"Percentage of things\"\n",
-      "name_of_something:\n",
-      "  type: string\n",
-      "  description: \"Name of something\"\n",
-      "swtich_value:\n",
-      "  type: boolean\n",
-      "  description: \"Is the switch on of off\"\n",
-      "collection_of_things:\n",
-      "  type: array\n",
-      "  description: \"This store collection of values\"\n",
-      "output_object:\n",
-      "  type: object\n",
-      "  description: \"Object output\"\n",
-      "output_file:\n",
-      "  type: file\n",
-      "  description: \"This a path to the output file\"\n",
-      "output_image:\n",
-      "  type: image\n",
-      "  description: \"This a path to the output image\"\n",
-      "md5sum:\n",
-      "  type: string\n",
-      "  description: \"MD5SUM of an object\"\n",
-      "  highlight: true\n"
-     ]
-    }
-   ],
-   "source": [
-    "cat $PIPESTAT_RESULTS_SCHEMA"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Reporting\n",
-    "\n",
-    "Naturally, the command line interface provides access to all the Python API functionalities of `pipestat`. So, for example, to report a result and back the object by a file use:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Reported records for 'sample1' in 'test' namespace:\n",
-      " - number_of_things: 100\n"
-     ]
-    }
-   ],
-   "source": [
-    "pipestat report -i number_of_things -v 100"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The result has been reported and the database file has been updated:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "test:\n",
-      "  sample1:\n",
-      "    number_of_things: 100\n"
-     ]
-    }
-   ],
-   "source": [
-    "cat $PIPESTAT_RESULTS_FILE"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's report another result:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Reported records for 'sample1' in 'test' namespace:\n",
-      " - percentage_of_things: 1.1\n"
-     ]
-    }
-   ],
-   "source": [
-    "pipestat report -i percentage_of_things -v 1.1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "test:\n",
-      "  sample1:\n",
-      "    number_of_things: 100\n",
-      "    percentage_of_things: 1.1\n"
-     ]
-    }
-   ],
-   "source": [
-    "cat $PIPESTAT_RESULTS_FILE"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Inspection\n",
-    "\n",
-    "`pipestat inspect` command is a way to briefly look at the general `PipestatManager` state, like number of records, type of backend etc."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "PipestatManager (test)\n",
-      "Backend: File \n",
-      " - results: /var/folders/h8/8npwnh2s4rb8lr6hsy2ydrsh0000gp/T/tmp.hk8q23wT\n",
-      " - status: /var/folders/h8/8npwnh2s4rb8lr6hsy2ydrsh0000gp/T)\n",
-      "Results schema source: ../tests/data/sample_output_schema.yaml\n",
-      "Status schema source: /usr/local/lib/python3.9/site-packages/pipestat/schemas/status_schema.yaml\n",
-      "Records count: 1\n",
-      "Highlighted results: md5sum\n"
-     ]
-    }
-   ],
-   "source": [
-    "pipestat inspect"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In order to display the contents of the results file or database table associated with the indicated namespace, add `--data` flag:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "PipestatManager (test)\n",
-      "Backend: File \n",
-      " - results: /var/folders/h8/8npwnh2s4rb8lr6hsy2ydrsh0000gp/T/tmp.hk8q23wT\n",
-      " - status: /var/folders/h8/8npwnh2s4rb8lr6hsy2ydrsh0000gp/T)\n",
-      "Results schema source: ../tests/data/sample_output_schema.yaml\n",
-      "Status schema source: /usr/local/lib/python3.9/site-packages/pipestat/schemas/status_schema.yaml\n",
-      "Records count: 1\n",
-      "Highlighted results: md5sum\n",
-      "\n",
-      "Data:\n",
-      "test:\n",
-      "  sample1:\n",
-      "    number_of_things: 100\n",
-      "    percentage_of_things: 1.1\n"
-     ]
-    }
-   ],
-   "source": [
-    "pipestat inspect --data"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Retrieval\n",
-    "\n",
-    "Naturally, the reported results can be retrieved. Just call `pipestat retrieve` to do so:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 44,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1.1\n"
-     ]
-    }
-   ],
-   "source": [
-    "pipestat retrieve -i percentage_of_things"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Removal\n",
-    "\n",
-    "In order to remove a result call `pipestat remove`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Removed result 'percentage_of_things' for record 'sample1' from 'test' namespace\n"
-     ]
-    }
-   ],
-   "source": [
-    "pipestat remove -i percentage_of_things"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The results file and the state of the `PipestatManager` object reflect the removal:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 46,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "test:\n",
-      "  sample1:\n",
-      "    number_of_things: 100\n"
-     ]
-    }
-   ],
-   "source": [
-    "cat $PIPESTAT_RESULTS_FILE"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 47,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "PipestatManager (test)\n",
-      "Backend: File \n",
-      " - results: /var/folders/h8/8npwnh2s4rb8lr6hsy2ydrsh0000gp/T/tmp.hk8q23wT\n",
-      " - status: /var/folders/h8/8npwnh2s4rb8lr6hsy2ydrsh0000gp/T)\n",
-      "Results schema source: ../tests/data/sample_output_schema.yaml\n",
-      "Status schema source: /usr/local/lib/python3.9/site-packages/pipestat/schemas/status_schema.yaml\n",
-      "Records count: 1\n",
-      "Highlighted results: md5sum\n",
-      "\n",
-      "Data:\n",
-      "test:\n",
-      "  sample1:\n",
-      "    number_of_things: 100\n"
-     ]
-    }
-   ],
-   "source": [
-    "pipestat inspect --data"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Status management\n",
-    "\n",
-    "To manage pipeline status call `pipestat status <subcommand>`:\n",
-    "\n",
-    "- `set` to set pipeline statuses\n",
-    "- `get` to retrieve pipeline statuses\n",
-    "\n",
-    "Starting with `pipestat 0.0.3` the `--schema` argument is not required for status management."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 48,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pipestat status set running"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 49,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "running\n"
-     ]
-    }
-   ],
-   "source": [
-    "pipestat status get"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Note that only statuses defined in the status schema are supported:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 50,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "running:\n",
-      "  description: \"the pipeline is running\"\n",
-      "  color: [30, 144, 255] # dodgerblue\n",
-      "completed:\n",
-      "  description: \"the pipeline has completed\"\n",
-      "  color: [50, 205, 50] # limegreen\n",
-      "failed:\n",
-      "  description: \"the pipeline has failed\"\n",
-      "  color: [220, 20, 60] # crimson\n",
-      "waiting:\n",
-      "  description: \"the pipeline is waiting\"\n",
-      "  color: [240, 230, 140] # khaki\n",
-      "partial:\n",
-      "  description: \"the pipeline stopped before completion point\"\n",
-      "  color: [169, 169, 169] # darkgray\n"
-     ]
-    }
-   ],
-   "source": [
-    "cat /usr/local/lib/python3.9/site-packages/pipestat/schemas/status_schema.yaml"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## HTML Report Generation\n",
-    "\n",
-    "To generate a static html report, call `pipestat summarize --results-file PIPESTAT_RESULTS_FILE --schema PIPESTAT_RESULTS_SCHEMA`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 51,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "rm $PIPESTAT_RESULTS_FILE"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/docs_jupyter/pipestat b/docs_jupyter/pipestat
deleted file mode 100644
index e69de29b..00000000
diff --git a/docs_jupyter/python_api.ipynb b/docs_jupyter/python_api.ipynb
deleted file mode 100644
index d3d50884..00000000
--- a/docs_jupyter/python_api.ipynb
+++ /dev/null
@@ -1,1361 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "raw",
-   "metadata": {},
-   "source": [
-    "# Pipestat Python API\n",
-    "\n",
-    "Pipestat is a [Python package](https://pypi.org/project/pipestat/) for a standardized reporting of pipeline statistics. It formalizes a way to communicate between pipelines and downstream tools that analyze their results so that pipeline results can easily become input for downstream analyses.\n",
-    "\n",
-    "This tutorial is targeted toward pipeline developers, and shows how to use pipestat to manage pipeline results. This tutorial assumes you're writing your pipeline in Python; if not, there's another tutorial that accomplishes the same thing for any pipeline using the command-line interface.\n",
-    "\n",
-    "## Introduction\n",
-    "\n",
-    "To make your Python pipeline pipestat-compatible, you first need to initialize pipestat with some important configuration setup:\n",
-    "\n",
-    "1. **pipestat schema**: a path to a JSON-schema file that defines results reported by this pipeline\n",
-    "2. **pipeline_name**: defines a unique group name for reported results\n",
-    "3. **record_identifier**: a unique name for a particular *run* of the pipeline, typically a sample name\n",
-    "4. **backend**: where the results should be stored. Either path to a YAML-formatted file or pipestat config with PostgreSQL database login credentials\n",
-    "\n",
-    "## Back-end types\n",
-    "\n",
-    "Two types of back-ends are currently supported:\n",
-    "\n",
-    "1. a **file** (pass a file path to the constructor)  \n",
-    "The changes reported using the `report` method of `PipestatManger` will be securely written to the file. Currently only [YAML](https://yaml.org/) format is supported. \n",
-    "\n",
-    "2. a **PostgreSQL database** (pass a path to the pipestat config to the constructor)\n",
-    "This option gives the user the possibility to use a fully fledged database to back `PipestatManager`. \n",
-    "\n",
-    "\n",
-    "## Initializing a pipestat session\n",
-    "\n",
-    "Start by importing the `pipestat` package in Python."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pipestat\n",
-    "from jsonschema import ValidationError"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "After importing the package, we need to create an `PipestatManager` object. The object constructor requires a few pieces of information. We'll use a file as the back-end, by passing a file path string to the constructor. Let's create a temporary file first:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "/tmp/tmps01teih1.yaml\n"
-     ]
-    }
-   ],
-   "source": [
-    "from tempfile import mkstemp\n",
-    "\n",
-    "_, temp_file = mkstemp(suffix=\".yaml\")\n",
-    "print(temp_file)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now we can create a `PipestatManager` object that uses this file as the back-end:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Initialize PipestatBackend\n",
-      "Initialize FileBackend\n"
-     ]
-    }
-   ],
-   "source": [
-    "psm = pipestat.PipestatManager(\n",
-    "    record_identifier=\"sample1\",\n",
-    "    results_file_path=temp_file,\n",
-    "    schema_path=\"../tests/data/sample_output_schema.yaml\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Note: For schema_path, you will need to point to a **sample_output_schema.yaml**. An example file can be found here: https://github.com/pepkit/pipestat/blob/master/tests/data/sample_output_schema.yaml\n",
-    "\n",
-    "You can also put these settings into a config file and just pass that to the `config` argument, instead of specifying each argument separately. The results will be reported to a \"test\" namespace."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'default_pipeline_name'"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.pipeline_name"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "By default, `PipestatManager` instance is bound to the record it was initialized with. However, reporting or removing results for a different record can be enforced in the respective methods with `sameple_name` argument."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'sample1'"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.record_identifier"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Since we've used a newly created file, nothing has been reported yet:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "None\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(psm.retrieve_one(record_identifier='sample1'))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Using `psm.retrieve_one` at this stage will return `None`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "default_pipeline_name:\n",
-       "  project: {}\n",
-       "  sample: {}\n"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.data"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Reporting results"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To report a result, use a `report` method. It requires two pieces of information:\n",
-    "\n",
-    "1. record_identifier -- record to report the result for, for example a unique name of the sample (optional if provided at `PipestatManager` initialization stage)\n",
-    "2. values -- a Python `dict` of resultID-value pairs to report. The top level keys must correspond to the results identifiers defined in the schema\n",
-    "\n",
-    "### Available results defined in schemas\n",
-    "\n",
-    "To learn about the results that the current `PipestatManager` instance supports check out the `schema.result_schemas` property:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'number_of_things': {'type': 'integer', 'description': 'Number of things'},\n",
-       " 'percentage_of_things': {'type': 'number',\n",
-       "  'description': 'Percentage of things'},\n",
-       " 'name_of_something': {'type': 'string', 'description': 'Name of something'},\n",
-       " 'switch_value': {'type': 'boolean', 'description': 'Is the switch on or off'},\n",
-       " 'output_file': {'description': 'This a path to the output file',\n",
-       "  'type': 'object',\n",
-       "  'object_type': 'file',\n",
-       "  'properties': {'path': {'type': 'string'}, 'title': {'type': 'string'}},\n",
-       "  'required': ['path', 'title']},\n",
-       " 'output_image': {'description': 'This a path to the output image',\n",
-       "  'type': 'object',\n",
-       "  'object_type': 'image',\n",
-       "  'properties': {'path': {'type': 'string'},\n",
-       "   'thumbnail_path': {'type': 'string'},\n",
-       "   'title': {'type': 'string'}},\n",
-       "  'required': ['path', 'thumbnail_path', 'title']},\n",
-       " 'md5sum': {'type': 'string',\n",
-       "  'description': 'MD5SUM of an object',\n",
-       "  'highlight': True}}"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.result_schemas"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To learn about the actual required attributes of the reported results, like `file` or `image` (see: `output_file` and `output_image` results) select the `output_file` from the `result_schemas` property:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'description': 'This a path to the output file',\n",
-       " 'type': 'object',\n",
-       " 'object_type': 'file',\n",
-       " 'properties': {'path': {'type': 'string'}, 'title': {'type': 'string'}},\n",
-       " 'required': ['path', 'title']}"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.result_schemas[\"output_file\"]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Results composition enforcement\n",
-    "As you can see, to report a `output_file` result, you need to provide an object with `path` and `title` string attributes. If you fail to do so `PipestatManager` will issue an informative validation error:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "'title' is a required property\n",
-      "\n",
-      "Failed validating 'required' in schema:\n",
-      "    {'description': 'This a path to the output file',\n",
-      "     'object_type': 'file',\n",
-      "     'properties': {'path': {'type': 'string'},\n",
-      "                    'title': {'type': 'string'}},\n",
-      "     'required': ['path', 'title'],\n",
-      "     'type': 'object'}\n",
-      "\n",
-      "On instance:\n",
-      "    {'path': '/home/user/path.csv'}\n"
-     ]
-    }
-   ],
-   "source": [
-    "try:\n",
-    "    psm.report(record_identifier=\"sample1\", values={\"output_file\": {\"path\": \"/home/user/path.csv\"}})\n",
-    "except ValidationError as e:\n",
-    "    print(e)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's report a correct object this time:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[\"Reported records for 'sample1' in 'default_pipeline_name' :\\n - output_file: {'path': '/home/user/path.csv', 'title': 'CSV file with some data'}\",\n",
-       " \"Reported records for 'sample1' in 'default_pipeline_name' :\\n - pipestat_created_time: 2023-11-07 17:30:39\",\n",
-       " \"Reported records for 'sample1' in 'default_pipeline_name' :\\n - pipestat_modified_time: 2023-11-07 17:30:39\"]"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.report(record_identifier=\"sample1\",\n",
-    "    values={\n",
-    "        \"output_file\": {\n",
-    "            \"path\": \"/home/user/path.csv\",\n",
-    "            \"title\": \"CSV file with some data\",\n",
-    "        }\n",
-    "    }\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Inspect the object's database to verify whether the result has been successfully reported:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "default_pipeline_name:\n",
-       "  project: {}\n",
-       "  sample:\n",
-       "    sample1:\n",
-       "      output_file:\n",
-       "        path: /home/user/path.csv\n",
-       "        title: CSV file with some data\n",
-       "      pipestat_created_time: '2023-11-07 17:30:39'\n",
-       "      pipestat_modified_time: '2023-11-07 17:30:39'\n"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.data"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Or use the retrieve function (required for database backends):"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'output_file': {'path': '/home/user/path.csv',\n",
-       "  'title': 'CSV file with some data'},\n",
-       " 'pipestat_created_time': '2023-11-07 17:30:39',\n",
-       " 'pipestat_modified_time': '2023-11-07 17:30:39',\n",
-       " 'record_identifier': 'sample1'}"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.retrieve_one('sample1')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "No results duplication is allowed, unless you force overwrite:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "These results exist for 'sample1': output_file\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "False"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.report(record_identifier=\"sample1\",\n",
-    "    values={\n",
-    "        \"output_file\": {\n",
-    "            \"path\": \"/home/user/path_new.csv\",\n",
-    "            \"title\": \"new CSV file with some data\",\n",
-    "        }\n",
-    "    }\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "These results exist for 'sample1': output_file\n",
-      "Overwriting existing results: output_file\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "{'output_file': {'path': '/home/user/path_new.csv',\n",
-       "  'title': 'new CSV file with some data'},\n",
-       " 'pipestat_created_time': '2023-11-07 17:30:39',\n",
-       " 'pipestat_modified_time': '2023-11-07 17:30:48',\n",
-       " 'record_identifier': 'sample1'}"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.report(record_identifier=\"sample1\",\n",
-    "    values={\n",
-    "        \"output_file\": {\n",
-    "            \"path\": \"/home/user/path_new.csv\",\n",
-    "            \"title\": \"new CSV file with some data\",\n",
-    "        }\n",
-    "    },\n",
-    "    force_overwrite=True,\n",
-    ")\n",
-    "\n",
-    "psm.retrieve_one('sample1')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Most importantly, by backing the object by a file, the reported results persist -- another `PipestatManager` object reads the results when created:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Initialize PipestatBackend\n",
-      "Initialize FileBackend\n"
-     ]
-    }
-   ],
-   "source": [
-    "psm1 = pipestat.PipestatManager(\n",
-    "    pipeline_name=\"test\",\n",
-    "    record_identifier=\"sample1\",\n",
-    "    results_file_path=temp_file,\n",
-    "    schema_path=\"../tests/data/sample_output_schema.yaml\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'output_file': {'path': '/home/user/path_new.csv',\n",
-       "  'title': 'new CSV file with some data'},\n",
-       " 'pipestat_created_time': '2023-11-07 17:30:39',\n",
-       " 'pipestat_modified_time': '2023-11-07 17:30:48',\n",
-       " 'record_identifier': 'sample1'}"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.retrieve_one('sample1')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "That's because the contents are stored in the file we've specified at object creation stage:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "/tmp/tmps01teih1.yaml\n",
-      "default_pipeline_name:\n",
-      "  project: {}\n",
-      "  sample:\n",
-      "    sample1:\n",
-      "      output_file:\n",
-      "        path: /home/user/path_new.csv\n",
-      "        title: new CSV file with some data\n",
-      "      pipestat_created_time: '2023-11-07 17:30:39'\n",
-      "      pipestat_modified_time: '2023-11-07 17:30:48'\n"
-     ]
-    }
-   ],
-   "source": [
-    "!echo $temp_file\n",
-    "!cat $temp_file"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Note that two processes can securely report to a single file and single namespace since `pipestat` supports locks and race-free writes to control multi-user conflicts and prevent data loss.\n",
-    "\n",
-    "### Results type enforcement\n",
-    "\n",
-    "By default `PipestatManager` raises an exception if a non-compatible result value is reported. \n",
-    "\n",
-    "This behavior can be changed by setting `strict_type` to `True` in `PipestatManager.report` method. In this case `PipestatManager` tries to cast the reported results values to the Python classes required by schema. For example, if a result defined as `integer` is reported and a `str` value is passed, the eventual value will be `int`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'type': 'integer', 'description': 'Number of things'}"
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.result_schemas[\"number_of_things\"]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[\"Reported records for 'sample1' in 'default_pipeline_name' :\\n - number_of_things: 10\",\n",
-       " \"Reported records for 'sample1' in 'default_pipeline_name' :\\n - pipestat_modified_time: 2023-11-07 17:30:56\"]"
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.report(record_identifier=\"sample1\",values={\"number_of_things\": \"10\"}, strict_type=False)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The method will attempt to cast the value to a proper Python class and store the converted object. In case of a failure, an error will be raised:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "int() argument must be a string, a bytes-like object or a real number, not 'list'\n"
-     ]
-    }
-   ],
-   "source": [
-    "try:\n",
-    "    psm.report(\n",
-    "        record_identifier=\"sample2\", values={\"number_of_things\": []}, strict_type=False\n",
-    "    )\n",
-    "except TypeError as e:\n",
-    "    print(e)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Note that in this case we tried to report a result for a different record (`sample2`), which had to be enforced with `record_identifier` argument."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "default_pipeline_name:\n",
-       "  project: {}\n",
-       "  sample:\n",
-       "    sample1:\n",
-       "      output_file:\n",
-       "        path: /home/user/path_new.csv\n",
-       "        title: new CSV file with some data\n",
-       "      pipestat_created_time: '2023-11-07 17:30:39'\n",
-       "      pipestat_modified_time: '2023-11-07 17:30:56'\n",
-       "      number_of_things: '10'\n"
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.data"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Retrieving results\n",
-    "\n",
-    "Naturally, the reported results can be retrieved. Let's explore all the options the `PipestatManager.retrieve` method provides:\n",
-    "\n",
-    "To retrieve a *specific* result for a record, provide the identifiers:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'10'"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.retrieve_one(record_identifier=\"sample1\", result_identifier=\"number_of_things\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To retrieve *all* the results for a record, skip the `result_identifier` argument:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'output_file': {'path': '/home/user/path_new.csv',\n",
-       "  'title': 'new CSV file with some data'},\n",
-       " 'pipestat_created_time': '2023-11-07 17:30:39',\n",
-       " 'pipestat_modified_time': '2023-11-07 17:30:56',\n",
-       " 'number_of_things': '10',\n",
-       " 'record_identifier': 'sample1'}"
-      ]
-     },
-     "execution_count": 25,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.retrieve_one(record_identifier=\"sample1\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Removing results"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "`PipestatManager` object also supports results removal. Call `remove` method and provide `record_identifier` and  `result_identifier` arguments to do so:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Removed result 'number_of_things' for record 'sample1' from 'default_pipeline_name' namespace\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 26,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.remove(record_identifier=\"sample1\",result_identifier=\"number_of_things\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The entire record, skip the `result_identifier` argument:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Removing 'sample1' record\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 27,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.remove()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Verify that an appropriate entry from the results was deleted:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "default_pipeline_name:\n",
-       "  project: {}\n",
-       "  sample: {}\n"
-      ]
-     },
-     "execution_count": 28,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.backend._data"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Highligting results\n",
-    "\n",
-    "In order to highlight results we need to add an extra property in the pipestat results schema (`highlight: true`) under the result identifier that we wish to highlight. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Initialize PipestatBackend\n",
-      "Initialize FileBackend\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "/tmp/tmpa9fo3rk7.yaml\n"
-     ]
-    }
-   ],
-   "source": [
-    "from tempfile import mkstemp\n",
-    "\n",
-    "_, temp_file_highlight = mkstemp(suffix=\".yaml\")\n",
-    "print(temp_file_highlight)\n",
-    "\n",
-    "psm_highlight = pipestat.PipestatManager(\n",
-    "    pipeline_name=\"test_highlight\",\n",
-    "    record_identifier=\"sample1\",\n",
-    "    results_file_path=temp_file_highlight,\n",
-    "    schema_path=\"../tests/data/sample_output_schema_highlight.yaml\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "For example, result `log` is highlighted in this case:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'highlight': True,\n",
-       " 'description': 'The log file of the pipeline run',\n",
-       " 'type': 'object',\n",
-       " 'object_type': 'file',\n",
-       " 'properties': {'path': {'type': 'string'}, 'title': {'type': 'string'}},\n",
-       " 'required': ['path', 'title']}"
-      ]
-     },
-     "execution_count": 30,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm_highlight.result_schemas['log']"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The highlighting feature can be used by pipestat clients to present the highlighted results in a special way."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['log', 'profile', 'commands', 'version']"
-      ]
-     },
-     "execution_count": 31,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm_highlight.highlighted_results"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Pipeline status management\n",
-    "\n",
-    "Pipestat provides a pipeline status management system, which can be used to set and read pipeline status. To maintain the status information between sessions it uses flags or additional DB table if the `PipestatManager` object is backed with YAML file or PostgreSQL database, respectively.\n",
-    "\n",
-    "To set pipeline status use `set_status` method:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "psm.set_status(record_identifier=\"sample1\", status_identifier=\"running\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To get pipeline status use `get_status` method:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'running'"
-      ]
-     },
-     "execution_count": 33,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.get_status(record_identifier=\"sample1\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Allowable statuses and related metadata are defined in the status schema, which can be accessed via:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'running': {'description': 'the pipeline is running',\n",
-       "  'color': [30, 144, 255]},\n",
-       " 'completed': {'description': 'the pipeline has completed',\n",
-       "  'color': [50, 205, 50]},\n",
-       " 'failed': {'description': 'the pipeline has failed', 'color': [220, 20, 60]},\n",
-       " 'waiting': {'description': 'the pipeline is waiting',\n",
-       "  'color': [240, 230, 140]},\n",
-       " 'partial': {'description': 'the pipeline stopped before completion point',\n",
-       "  'color': [169, 169, 169]}}"
-      ]
-     },
-     "execution_count": 34,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.cfg['_status_schema']"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "`pipestat` Python package ships with a default status schema, so we did not have to provide the schema when constructing the `PipestatManager` object. Similarly, the flags containg directory is an optional configuration option. \n",
-    "\n",
-    "Please refer to the Python API documentation (`__init__` method) to see how to use custom status schema and flags directory."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Initializing `PipestatManager` without results schema\n",
-    "\n",
-    "Starting with `pipestat 0.0.3`, it is possible to initialize the `PipestatManager` object without specifying the results schema file. This feature comes in handy if `PipestatManager` is created with a sole intent to monitor pipeline status.\n",
-    "\n",
-    "Here's an example:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "No schema supplied.\n",
-      "Initialize PipestatBackend\n",
-      "Initialize FileBackend\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "/tmp/tmpxpe5w75w.yaml\n"
-     ]
-    }
-   ],
-   "source": [
-    "_, temp_file_no_schema = mkstemp(suffix=\".yaml\")\n",
-    "print(temp_file_no_schema)\n",
-    "\n",
-    "psm_no_schema = pipestat.PipestatManager(\n",
-    "    pipeline_name=\"test_no_schema\", results_file_path=temp_file_no_schema\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "As mentioned above, the pipeline status management capabilities are supported with no results schema defined:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'running'"
-      ]
-     },
-     "execution_count": 36,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm_no_schema.set_status(status_identifier=\"running\", record_identifier=\"sample1\")\n",
-    "psm_no_schema.get_status(record_identifier=\"sample1\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Generate static HTML Report using the `summarize` command\n",
-    "\n",
-    "You can generate a static browsable html report using the `summarize` function:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Building index page for pipeline: default_pipeline_name\n",
-      " * Creating sample pages\n",
-      " * Creating object pages\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'/tmp/reports/default_pipeline_name/index.html'"
-      ]
-     },
-     "execution_count": 37,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm.summarize()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Sample and Project Level Pipelines\n",
-    "\n",
-    "All of the examples above assume the user has a sample level pipeline. Pipestat defaults to setting pipeline_type = 'sample'. However, the user can set the pipeline_type = 'project'.\n",
-    "\n",
-    "Beginning in Pipestat 0.6.0, the user can call SamplePipestatManager() or ProjectPipestatManager() that do everything PipestatManager does but sets the pipeline_type to either 'sample' or 'project' respectively."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Initialize PipestatBackend\n",
-      "Initialize FileBackend\n",
-      "Initialize PipestatMgrSample\n"
-     ]
-    }
-   ],
-   "source": [
-    "psm_sample = pipestat. SamplePipestatManager(record_identifier=\"sample1\",\n",
-    "    results_file_path=temp_file,\n",
-    "    schema_path=\"../tests/data/sample_output_schema.yaml\",)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'description': 'This a path to the output file',\n",
-       " 'type': 'object',\n",
-       " 'object_type': 'file',\n",
-       " 'properties': {'path': {'type': 'string'}, 'title': {'type': 'string'}},\n",
-       " 'required': ['path', 'title']}"
-      ]
-     },
-     "execution_count": 39,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psm_sample.result_schemas[\"output_file\"]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## PipestatBoss\n",
-    "\n",
-    "Also in Pipestat 0.6.0, the user can call PipestatBoss with the sample arguments as SamplePipestatManager or ProjectPipestatmanger while also including a list of pipeline_types. This will create and object containing multiple PipestatManager objects."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Initialize PipestatBoss\n",
-      "Initialize PipestatBackend\n",
-      "Initialize FileBackend\n",
-      "Initialize PipestatMgrSample\n",
-      "Initialize PipestatBackend\n",
-      "Initialize FileBackend\n",
-      "Initialize PipestatMgrProject\n"
-     ]
-    }
-   ],
-   "source": [
-    "psb = pipestat.PipestatBoss(pipeline_list=['sample', 'project',], \n",
-    "                   schema_path=\"../tests/data/sample_output_schema.yaml\", results_file_path=temp_file)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[\"Reported records for 'sample1' in 'default_pipeline_name' :\\n - output_file: {'path': '/home/user/path.csv', 'title': 'CSV file with some data'}\",\n",
-       " \"Reported records for 'sample1' in 'default_pipeline_name' :\\n - pipestat_created_time: 2023-11-07 17:31:18\",\n",
-       " \"Reported records for 'sample1' in 'default_pipeline_name' :\\n - pipestat_modified_time: 2023-11-07 17:31:18\"]"
-      ]
-     },
-     "execution_count": 41,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "psb.samplemanager.report(record_identifier=\"sample1\",values={\n",
-    "        \"output_file\": {\n",
-    "            \"path\": \"/home/user/path.csv\",\n",
-    "            \"title\": \"CSV file with some data\",\n",
-    "        }\n",
-    "    })"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "interpreter": {
-   "hash": "ac2eaa0ea0ebeafcc7822e65e46aa9d4f966f30b695406963e145ea4a91cd4fc"
-  },
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/mkdocs.yml b/mkdocs.yml
deleted file mode 100644
index 8055501b..00000000
--- a/mkdocs.yml
+++ /dev/null
@@ -1,35 +0,0 @@
-site_name: pipestat
-site_url: http://pipestat.databio.org/
-site_logo: img/pipestat_logo_light.svg
-repo_url: http://github.com/pepkit/pipestat
-pypi_name: pipestat
-
-nav:
-  - Getting Started:
-    - Introduction: README.md
-    - Install and configure: install.md
-  - How-to guides:
-    - Quickstart: api_quickstart.md
-    - Use Python API: python_api.md
-    - Use command line interface: cli.md
-    - Configure pipestat: configuration.md
-  - Reference:
-    - CLI usage: usage.md
-    - Configuration format: config.md
-    - Environment variables: env_vars.md
-    - Pipestat specification: pipestat_specification.md
-    - Python API: autodoc_build/pipestat.md
-    - Support: https://github.com/pepkit/pipestat/issues
-    - Contributing: contributing.md
-    - Changelog: changelog.md
-
-theme: databio
-
-plugins:
-- databio:
-    jupyter_source: "docs_jupyter"
-    jupyter_build: "docs_jupyter/build"
-    autodoc_build: "docs/autodoc_build"
-    autodoc_package: "pipestat"
-    no_top_level: true
-- search
diff --git a/pipestat/_version.py b/pipestat/_version.py
index 777f190d..8088f751 100644
--- a/pipestat/_version.py
+++ b/pipestat/_version.py
@@ -1,1 +1,1 @@
-__version__ = "0.8.0"
+__version__ = "0.8.1"
diff --git a/pipestat/jinja_templates/footer.html b/pipestat/jinja_templates/footer.html
index 78bc6457..0a7eca5a 100644
--- a/pipestat/jinja_templates/footer.html
+++ b/pipestat/jinja_templates/footer.html
@@ -1,3 +1,3 @@
 <div class="wrapper">
-Generated with <code>looper v{{ version }}</code>
+Generated with <code>Pipestat v{{ version }}</code>
 <span style="float:right;">&copy; 2018-2024 <a href="http://databio.org/" target="_new">Sheffield Computational Biology Lab</a></span>
diff --git a/pipestat/jinja_templates/glossary.html b/pipestat/jinja_templates/glossary.html
index 78dff54c..017c6df5 100644
--- a/pipestat/jinja_templates/glossary.html
+++ b/pipestat/jinja_templates/glossary.html
@@ -2,7 +2,7 @@
 <html lang="en">
     <head>
       {% include "head.html" %}
-      <title>Looper: status</title>
+      <title>{{ pipeline_name }} Glossary</title>
     </head>
     {{ navbar }}
     <body>
diff --git a/pipestat/jinja_templates/index.html b/pipestat/jinja_templates/index.html
index 0ff88b01..d9431a29 100644
--- a/pipestat/jinja_templates/index.html
+++ b/pipestat/jinja_templates/index.html
@@ -212,7 +212,7 @@
 	<link
 		href="https://unpkg.com/bootstrap-table@1.15.4/dist/extensions/fixed-columns/bootstrap-table-fixed-columns.css"
 		rel="stylesheet">
-	<title>Looper: {{ project_name }} summary</title>
+	<title>{{ pipeline_name }} Summary </title>
 	<style>
 		.table td,
 		.table th {
diff --git a/pipestat/jinja_templates/navbar.html b/pipestat/jinja_templates/navbar.html
index 65265f09..c9c68586 100644
--- a/pipestat/jinja_templates/navbar.html
+++ b/pipestat/jinja_templates/navbar.html
@@ -9,8 +9,8 @@
               {{ navbar_links }}
             </ul>
             <ul class="nav navbar-nav navbar-right">
-              <a class="nav-link left" href="http://looper.databio.org/" target="_blank"><i class="fa fa-2x fa-book" aria-hidden="true"></i></a>
-              <a class="nav-link left" href="https://github.com/pepkit/looper" target="_blank"><i class="fa fa-2x fa-github" aria-hidden="true"></i></a>
+              <a class="nav-link left" href="https://pep.databio.org/pipestat/" target="_blank"><i class="fa fa-2x fa-book" aria-hidden="true"></i></a>
+              <a class="nav-link left" href="https://github.com/pepkit/pipestat" target="_blank"><i class="fa fa-2x fa-github" aria-hidden="true"></i></a>
             </ul>
           </div>
         </nav>
diff --git a/pipestat/jinja_templates/navbar_list_parent.html b/pipestat/jinja_templates/navbar_list_parent.html
index bc41dce1..8b57d58a 100644
--- a/pipestat/jinja_templates/navbar_list_parent.html
+++ b/pipestat/jinja_templates/navbar_list_parent.html
@@ -2,7 +2,7 @@
 <html lang="en">
     <head>
       {% include "head.html" %}
-      <title>Looper: {{ header }}</title>
+      <title>{{pipeline_name}}: {{ header }}</title>
     </head>
     {{ navbar }}
     <body>
diff --git a/pipestat/jinja_templates/object.html b/pipestat/jinja_templates/object.html
index 6d5dc075..9d4f04f5 100644
--- a/pipestat/jinja_templates/object.html
+++ b/pipestat/jinja_templates/object.html
@@ -3,7 +3,7 @@
 
 <head>
 	{% include "head.html" %}
-	<title>Looper: {{ name }} objects</title>
+	<title>Pipestat: {{ pipeline_name }} objects</title>
 </head>
 {{ navbar }}
 
diff --git a/pipestat/jinja_templates/sample.html b/pipestat/jinja_templates/sample.html
index 636fe880..0c4da793 100644
--- a/pipestat/jinja_templates/sample.html
+++ b/pipestat/jinja_templates/sample.html
@@ -9,7 +9,7 @@
             $('[data-toggle="popover"]').popover();
         });
     </script>
-    <title>Looper: {{ sample_name }}</title>
+    <title>Pipestat: {{ sample_name }}</title>
 </head>
 {{ navbar }}
 
diff --git a/pipestat/jinja_templates/status.html b/pipestat/jinja_templates/status.html
index 7df70682..80b2adee 100644
--- a/pipestat/jinja_templates/status.html
+++ b/pipestat/jinja_templates/status.html
@@ -2,7 +2,7 @@
 <html lang="en">
     <head>
       {% include "head.html" %}
-      <title>Looper: status</title>
+      <title>{{ pipeline_name }} Status</title>
     </head>
     {{ navbar }}
     <body>
diff --git a/pipestat/reports.py b/pipestat/reports.py
index 4bbd6a75..702d57a3 100644
--- a/pipestat/reports.py
+++ b/pipestat/reports.py
@@ -1,4 +1,5 @@
 """ Generate HTML reports """
+
 import shutil
 
 import jinja2
@@ -83,9 +84,11 @@ def __call__(
         self.amendments_str = "_".join(self.amendment) if self.amendment else ""
         self.pipeline_reports = os.path.join(
             self.reports_dir,
-            f"{self.pipeline_name}_{self.amendments_str}"
-            if self.amendments_str
-            else self.pipeline_name,
+            (
+                f"{self.pipeline_name}_{self.amendments_str}"
+                if self.amendments_str
+                else self.pipeline_name
+            ),
         )
         self.prj_index_html_path = project_index_html
         self.index_html_path = os.path.join(self.pipeline_reports, "index.html")
@@ -99,11 +102,11 @@ def __call__(
         navbar = self.create_navbar(
             navbar_links=self.create_navbar_links(
                 wd=self.pipeline_reports,
-                project_index_html_relpath=os.path.relpath(
-                    self.prj_index_html_path, self.pipeline_reports
-                )
-                if self.prj_index_html_path
-                else None,
+                project_index_html_relpath=(
+                    os.path.relpath(self.prj_index_html_path, self.pipeline_reports)
+                    if self.prj_index_html_path
+                    else None
+                ),
             ),
             index_html_relpath=os.path.relpath(self.index_html_path, self.pipeline_reports),
         )
@@ -164,7 +167,12 @@ def create_object_parent_html(self, navbar, footer):
             pages.append(os.path.relpath(page_path, self.pipeline_reports))
 
         template_vars = dict(
-            navbar=navbar, footer=footer, labels=labels, pages=pages, header="Objects"
+            navbar=navbar,
+            footer=footer,
+            labels=labels,
+            pages=pages,
+            header="Objects",
+            pipeline_name=self.pipeline_name,
         )
         _LOGGER.debug(f"object navbar_list_parent.html | template_vars:" f"\n{template_vars}")
         return render_jinja_template("navbar_list_parent.html", self.jinja_env, template_vars)
@@ -204,7 +212,12 @@ def create_sample_parent_html(self, navbar, footer):
                     labels.append(sample_name)
 
         template_vars = dict(
-            navbar=navbar, footer=footer, labels=labels, pages=pages, header="Records"
+            navbar=navbar,
+            footer=footer,
+            labels=labels,
+            pages=pages,
+            header="Records",
+            pipeline_name=self.pipeline_name,
         )
         _LOGGER.debug(f"sample navbar_list_parent.html | template_vars:" f"\n{template_vars}")
         return render_jinja_template("navbar_list_parent.html", self.jinja_env, template_vars)
@@ -390,6 +403,7 @@ def create_object_htmls(self, navbar, footer):
                         figures=[],
                         links=links,
                         desc=link_desc,
+                        pipeline_name=self.pipeline_name,
                     )
                     save_html(
                         html_page_path,
@@ -468,7 +482,12 @@ def create_object_htmls(self, navbar, footer):
                     )
 
     def create_glossary_html(self, glossary_table, navbar, footer):
-        template_vars = dict(glossary_table=glossary_table, navbar=navbar, footer=footer)
+        template_vars = dict(
+            glossary_table=glossary_table,
+            navbar=navbar,
+            footer=footer,
+            pipeline_name=self.pipeline_name,
+        )
         _LOGGER.debug(f"glossary.html | template_vars:\n{template_vars}")
         return render_jinja_template("glossary.html", self.jinja_env, template_vars)
 
@@ -615,7 +634,12 @@ def create_status_html(self, status_table, navbar, footer):
         :return str: rendered status HTML file
         """
         _LOGGER.debug("Building status page...")
-        template_vars = dict(status_table=status_table, navbar=navbar, footer=footer)
+        template_vars = dict(
+            status_table=status_table,
+            navbar=navbar,
+            footer=footer,
+            pipeline_name=self.pipeline_name,
+        )
         _LOGGER.debug(f"status.html | template_vars:\n{template_vars}")
         return render_jinja_template("status.html", self.jinja_env, template_vars)
 
@@ -703,7 +727,7 @@ def create_index_html(self, navbar, footer):
 
                 for key in all_result_identifiers:
                     if key not in sample_stat_results.keys():
-                        sample_stat_results[key] = "None reported"
+                        sample_stat_results[key] = ""
 
                 # Sort to ensure alignment in the table
                 sorted_sample_stat_results = dict(sorted(sample_stat_results.items()))
@@ -737,8 +761,10 @@ def create_index_html(self, navbar, footer):
         )
         # Create status page with each sample's status listed
         status_tab = create_status_table(
+            report_obj=self,
             project=self.prj,
             pipeline_reports_dir=self.pipeline_reports,
+            portable=self.portable,
         )
         save_html(
             path=os.path.join(self.pipeline_reports, "status.html"),
@@ -761,7 +787,7 @@ def create_index_html(self, navbar, footer):
             columns_json=dumps(columns),
             table_row_data=table_row_data,
             project_name=self.prj.cfg[PROJECT_NAME],
-            pipeline_name=self.prj.cfg[PIPELINE_NAME],
+            pipeline_name=self.pipeline_name,
             stats_json=self._stats_to_json_str(),
             project_objects=project_objects,
             footer=footer,
@@ -1146,12 +1172,14 @@ def uniqify(seq):
     return [x for x in seq if not (x in seen or seen_add(x))]
 
 
-def create_status_table(project, pipeline_reports_dir: str) -> str:
+def create_status_table(report_obj, project, pipeline_reports_dir: str, portable: bool) -> str:
     """
     Creates status table, the core of the status page.
 
+    :param report_obj: The HTML builder object
     :param PipestatManager project: project to get the results for
     :param str pipeline_reports_dir: path to the pipeline reports directory
+    :param bool portable: is the report to be portable?
     :return str: rendered status HTML file
     """
 
@@ -1214,6 +1242,12 @@ def _warn(what, e, sn):
                     0
                 ]  # Assumes the log file will be in status dir
                 assert os.path.exists(log), FileNotFoundError(f"Not found: {log}")
+                if portable:
+                    new_log_path = report_obj._create_copy_for_porting(
+                        parent_path=log,
+                        record_identifier=sample_name,
+                    )
+                    log = new_log_path
                 log_link_names.append(os.path.basename(log))
                 log_paths.append(os.path.relpath(log, pipeline_reports_dir))
             except Exception as e:
diff --git a/requirements/requirements-doc.txt b/requirements/requirements-doc.txt
deleted file mode 100644
index 9da698b2..00000000
--- a/requirements/requirements-doc.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-https://github.com/databio/mkdocs-databio/archive/master.zip
-https://github.com/pepkit/pipestat/archive/master.zip
-markdown-include
-mkdocs>=1.0
-pydoc-markdown
-sqlmodel>=0.0.14
-eido
\ No newline at end of file
diff --git a/update_api_docs.sh b/update_api_docs.sh
deleted file mode 100755
index ef1083f4..00000000
--- a/update_api_docs.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/bash
-lucidoc pipestat -P rst > docs/api_docs.md
diff --git a/update_usage_docs.sh b/update_usage_docs.sh
deleted file mode 100755
index 10aba076..00000000
--- a/update_usage_docs.sh
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/bin/bash
-
-# This little bash script just updates the docs/usage.md file with
-# latest usage, for the installed version.
-# Run this when updating version to update the usage docs.
-cp docs/usage.template usage.template
-
-for cmd in "--help" "report --help" "inspect --help" "remove --help" "retrieve --help" "status --help" "status get --help" "status set --help"; do
-	echo $cmd
-	echo -e "## \`pipestat $cmd\`" > USAGE_header.temp
-	pipestat $cmd --help > USAGE.temp 2>&1
-	# sed -i 's/^/\t/' USAGE.temp
-	sed -i.bak '1s;^;\`\`\`console\
-;' USAGE.temp
-#	sed -i '1s/^/\n\`\`\`console\n/' USAGE.temp
-	echo -e "\`\`\`\n" >> USAGE.temp
-	#sed -i -e "/\`looper $cmd\`/r USAGE.temp" -e '$G' usage.template  # for -in place inserts
-	cat USAGE_header.temp USAGE.temp >> usage.template # to append to the end
-done
-rm USAGE.temp
-rm USAGE_header.temp
-rm USAGE.temp.bak
-mv usage.template  docs/usage.md
-cat docs/usage.md
-#rm USAGE.temp


Test patch:
diff --git a/tests/conftest.py b/tests/conftest.py
index 78364ba1..0f593b79 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -31,6 +31,19 @@
     register(print, f"Some tests require a test database. To initiate it, run:\n{DB_CMD}")
     SERVICE_UNAVAILABLE = True
 
+try:
+    result = subprocess.check_output(
+        "pipestat report --c 'tests/data/config.yaml' -i 'name_of_something' -v 'test_value' -r 'dependency_value'",
+        shell=True,
+    )
+    DB_DEPENDENCIES = True
+except:
+    register(
+        print,
+        f"Warning: you must install dependencies with pip install pipestat['dbbackend'] to run database tests.",
+    )
+    DB_DEPENDENCIES = False
+
 
 def get_data_file_path(filename: str) -> str:
     data_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data")
diff --git a/tests/test_db_only_mode.py b/tests/test_db_only_mode.py
index 0251710e..5bc0d32f 100644
--- a/tests/test_db_only_mode.py
+++ b/tests/test_db_only_mode.py
@@ -4,10 +4,14 @@
 from pipestat.const import *
 from .conftest import DB_URL
 
-from .conftest import SERVICE_UNAVAILABLE
-from sqlmodel import SQLModel, create_engine
+from .conftest import SERVICE_UNAVAILABLE, DB_DEPENDENCIES
 
-from sqlmodel.main import default_registry
+try:
+    from sqlmodel import SQLModel, create_engine
+
+    from sqlmodel.main import default_registry
+except ModuleNotFoundError:
+    pass
 
 
 class ContextManagerDBTesting:
@@ -30,6 +34,7 @@ def __exit__(self, exc_type, exc_value, exc_traceback):
         self.connection.close()
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires service X to be available")
 class TestDatabaseOnly:
     # TODO: parameterize this against different schemas.
diff --git a/tests/test_init.py b/tests/test_init.py
index 1211a6f7..d542b4dd 100644
--- a/tests/test_init.py
+++ b/tests/test_init.py
@@ -9,12 +9,13 @@
 from pipestat.exceptions import *
 from pipestat.parsed_schema import SCHEMA_PIPELINE_NAME_KEY
 from tempfile import NamedTemporaryFile, TemporaryDirectory
-from .conftest import STANDARD_TEST_PIPE_ID
+from .conftest import STANDARD_TEST_PIPE_ID, DB_DEPENDENCIES
 from .conftest import SERVICE_UNAVAILABLE
 from pipestat.helpers import init_generic_config
 from pipestat.const import PIPESTAT_GENERIC_CONFIG, SCHEMA_KEY
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires postgres service to be available")
 class TestPipestatManagerInstantiation:
     def test_obj_creation_file(self, schema_file_path, results_file_path):
@@ -82,7 +83,6 @@ def test_create_results_file(self, schema_file_path):
         )
         assert os.path.exists(tmp_res_file)
 
-    # @pytest.mark.skip()
     def test_use_other_project_name_file(self, schema_file_path, tmp_path):
         """Results file can be used with just one project name"""
         tmp_res_file = os.path.join(mkdtemp(), "res.yml")
@@ -111,7 +111,6 @@ def test_use_other_project_name_file(self, schema_file_path, tmp_path):
                 results_file_path=tmp_res_file,
                 schema_path=temp_schema_path,
             )
-        # exp_msg = f"'{tmp_res_file}' is already used to report results for a different (not {ns2}) namespace: {psm1.schema.pipeline_name}"
         exp_msg = f"'{tmp_res_file}' is already in use for 1 namespaces: {psm1.cfg[SCHEMA_KEY].pipeline_name} and multi_pipelines = False."
         obs_msg = str(exc_ctx.value)
         assert obs_msg == exp_msg
diff --git a/tests/test_pipestat.py b/tests/test_pipestat.py
index 9762317a..02be1171 100644
--- a/tests/test_pipestat.py
+++ b/tests/test_pipestat.py
@@ -23,6 +23,7 @@
     SERVICE_UNAVAILABLE,
     DB_URL,
     REC_ID,
+    DB_DEPENDENCIES,
 )
 from tempfile import NamedTemporaryFile, TemporaryDirectory
 
@@ -44,6 +45,7 @@ def assert_is_in_files(fs, s):
             assert s in fh.read()
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires service X to be available")
 class TestSplitClasses:
     @pytest.mark.parametrize(
@@ -144,6 +146,7 @@ def test_basics_project_level(
                     psm.retrieve_one(record_identifier=rec_id)
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires postgres service to be available")
 class TestReporting:
     @pytest.mark.parametrize(
@@ -500,6 +503,7 @@ def test_report_formatter(
             assert value in results[0]
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires service X to be available")
 class TestRetrieval:
     @pytest.mark.parametrize(
@@ -669,6 +673,7 @@ def test_retrieve_nonexistent(
             # assert len(result['records'][0]) == 0
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires postgres service to be available")
 class TestRemoval:
     @pytest.mark.parametrize(["rec_id", "res_id", "val"], [("sample2", "number_of_things", 1)])
@@ -822,6 +827,7 @@ def test_last_result_removal_removes_record(
                 result = psm.retrieve_one(record_identifier=rec_id)
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires postgres service to be available")
 class TestNoRecordID:
     @pytest.mark.parametrize(
@@ -940,6 +946,7 @@ def test_highlighting_works(highlight_schema_file_path, results_file_path):
         assert psm.highlighted_results == schema_highlighted_results
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires service X to be available")
 class TestEnvVars:
     def test_no_config__psm_is_built_from_env_vars(
@@ -968,6 +975,8 @@ def test_config__psm_is_built_from_config_file_env_var(self, monkeypatch, config
             pytest.fail(f"Error during pipestat manager creation: {e}")
 
 
+@pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires service X to be available")
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 def test_no_constructor_args__raises_expected_exception():
     """See Issue #3 in the repository."""
     with pytest.raises(SchemaNotFoundError):
@@ -1017,6 +1026,7 @@ def absolutize_file(f: str) -> str:
         ]
     ],
 )
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires service X to be available")
 @pytest.mark.parametrize("backend_data", [BACKEND_KEY_FILE, BACKEND_KEY_DB], indirect=True)
 def test_manager_has_correct_status_schema_and_status_schema_source(
@@ -1028,6 +1038,7 @@ def test_manager_has_correct_status_schema_and_status_schema_source(
         assert psm.cfg[STATUS_SCHEMA_SOURCE_KEY] == exp_status_schema_path
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires service X to be available")
 class TestPipestatBoss:
     @pytest.mark.parametrize("backend", ["file", "db"])
@@ -1064,6 +1075,7 @@ def test_basic_pipestatboss(
                     psb.projectmanager.set_status(record_identifier=r, status_identifier="running")
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires service X to be available")
 class TestHTMLReport:
     @pytest.mark.parametrize("backend", ["file", "db"])
@@ -1198,6 +1210,7 @@ def test_zip_html_report_portable(
             assert len(zip_files) > 0
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires service X to be available")
 class TestTableCreation:
     @pytest.mark.parametrize("backend", ["file", "db"])
@@ -1257,6 +1270,7 @@ def test_basics_table_for_project(
             assert table_paths is not None
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires service X to be available")
 class TestPipestatCLI:
     @pytest.mark.parametrize(
@@ -1356,6 +1370,7 @@ def test_basics(
                 main(test_args=x)
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires service X to be available")
 class TestFileTypeLinking:
     @pytest.mark.parametrize("backend", ["file", "db"])
@@ -1405,6 +1420,7 @@ def test_linking(
                 print(files)
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires service X to be available")
 class TestTimeStamp:
     @pytest.mark.parametrize(
@@ -1540,6 +1556,7 @@ def test_list_recent_results(
             assert len(results["records"]) == 10
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires service X to be available")
 class TestSelectRecords:
     @pytest.mark.parametrize("backend", ["file", "db"])
@@ -2127,6 +2144,8 @@ def test_select_distinct_string(
             assert len(result3) == 6
 
 
+@pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires service X to be available")
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 class TestPipestatIter:
     @pytest.mark.parametrize("backend", ["file", "db"])
     def test_pipestat_iter(
@@ -2175,7 +2194,7 @@ def test_multi_results_not_implemented(
         backend,
         range_values,
     ):
-        with NamedTemporaryFile() as f, TemporaryDirectory() as d, ContextManagerDBTesting(DB_URL):
+        with NamedTemporaryFile() as f, TemporaryDirectory() as d:
             results_file_path = f.name
             temp_dir = d
             single_results_file_path = "{record_identifier}_results.yaml"
@@ -2196,7 +2215,7 @@ def test_multi_results_basic(
         backend,
         range_values,
     ):
-        with TemporaryDirectory() as d, ContextManagerDBTesting(DB_URL):
+        with TemporaryDirectory() as d:
             temp_dir = d
             single_results_file_path = "{record_identifier}_results.yaml"
             results_file_path = os.path.join(temp_dir, single_results_file_path)
@@ -2223,7 +2242,7 @@ def test_multi_results_summarize(
         backend,
         range_values,
     ):
-        with TemporaryDirectory() as d, ContextManagerDBTesting(DB_URL):
+        with TemporaryDirectory() as d:
             temp_dir = d
             single_results_file_path = "{record_identifier}/results.yaml"
             results_file_path = os.path.join(temp_dir, single_results_file_path)
@@ -2243,6 +2262,7 @@ def test_multi_results_summarize(
             assert r_id in data[psm.pipeline_name][psm.pipeline_type].keys()
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires service X to be available")
 class TestSetIndexTrue:
     @pytest.mark.parametrize(
diff --git a/tests/test_status.py b/tests/test_status.py
index a89ed003..27ad7c72 100644
--- a/tests/test_status.py
+++ b/tests/test_status.py
@@ -6,13 +6,20 @@
 from pipestat import SamplePipestatManager
 
 from pipestat.const import STATUS_FILE_DIR, FILE_KEY
-from .conftest import BACKEND_KEY_DB, BACKEND_KEY_FILE, DB_URL, SERVICE_UNAVAILABLE
+from .conftest import (
+    BACKEND_KEY_DB,
+    BACKEND_KEY_FILE,
+    DB_URL,
+    SERVICE_UNAVAILABLE,
+    DB_DEPENDENCIES,
+)
 
 from .test_db_only_mode import ContextManagerDBTesting
 from pipestat.exceptions import UnrecognizedStatusError
 from tempfile import NamedTemporaryFile
 
 
+@pytest.mark.skipif(not DB_DEPENDENCIES, reason="Requires dependencies")
 @pytest.mark.skipif(SERVICE_UNAVAILABLE, reason="requires postgres service to be available")
 class TestStatus:
     def test_status_file_default_location(self, schema_file_path, results_file_path):