Preliminary implementation of the API and SDK.

Author: pkhalaj

.gitignore

@@ -50,4 +50,12 @@ coverage.xml
 *.pot
 
 # Sphinx documentation
-docs/_build/
+docs/build/
+*.rst
+
+# the actual config file [HAS TO BE ALWAYS EXCLUDED!]
+config.yaml
+config.yml
+
+# temp log and storage for the test database
+__temp*

.readthedocs.yaml

@@ -0,0 +1,23 @@
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version and other tools you might need
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.12"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+  configuration: docs/source/conf.py
+
+# Optional but recommended, declare the Python requirements required
+# to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+# python:
+#    install:
+#    - requirements: docs/requirements.txt

trolldb/__init__.py __init__.py

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

docs/Makefile

@@ -0,0 +1,64 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath('../../trolldb'))
+
+# -- Project information -----------------------------------------------------
+
+project = 'Pytroll-db'
+copyright = '2024, Pytroll'
+author = 'Pouria Khalaj'
+
+# The full version, including alpha/beta/rc tags
+release = '0.1'
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.viewcode',
+    'sphinx.ext.napoleon',
+]
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ["*test*"]
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+# html_static_path = ['_static']
+
+autodoc_default_options = {
+    'member-order': 'bysource',
+    'special-members': '__init__',
+    'undoc-members': True,
+    'exclude-members': '__weakref__'
+}
+
+master_doc = "index"

docs/source/conf.py

@@ -0,0 +1,11 @@
+"""
+Note:
+    The following applies to the :package:`trolldb.api` and all its subpackages/modules.
+
+    To avoid double documentations and inconsistencies, only non-FastAPI components are documented via the docstrings.
+    For the documentation related to the FastAPI components, check out the auto-generated documentation by FastAPI.
+    Assuming that the API server is running on `<http://localhost:8000>`_ (example) the auto-generated documentation can
+    be accessed via either `<http://localhost:8000/redoc>`_ or  `<http://localhost:8000/docs>`_.
+
+    Read more at `FastAPI automatics docs <https://fastapi.tiangolo.com/features/#automatic-docs>`_.
+"""

trolldb/api/__init__.py

@@ -0,0 +1,101 @@
+"""
+The module which includes the main functionalities of the API package. This is the main module which is supposed to be
+imported by the users of the package.
+
+Note:
+    Functions in this module are decorated with
+    `pydantic.validate_call <https://docs.pydantic.dev/latest/api/validate_call/#pydantic.validate_call_decorator.validate_call>`_
+    so that their arguments can be validated using the corresponding type hints, when calling the function at runtime.
+
+Note:
+    The following applies to the :obj:`trolldb.api` package and all its subpackages/modules.
+
+    To avoid redundant documentation and inconsistencies, only non-FastAPI components are documented via the docstrings.
+    For the documentation related to the FastAPI components, check out the auto-generated documentation by FastAPI.
+    Assuming that the API server is running on `<http://localhost:8000>`_ (example) the auto-generated documentation can
+    be accessed via either `<http://localhost:8000/redoc>`_ or  `<http://localhost:8000/docs>`_.
+
+    Read more at `FastAPI automatics docs <https://fastapi.tiangolo.com/features/#automatic-docs>`_.
+"""
+
+import asyncio
+import time
+from contextlib import contextmanager
+from multiprocessing import Process
+
+import uvicorn
+from fastapi import FastAPI
+from pydantic import FilePath, validate_call
+
+from api.routes import api_router
+from config.config import AppConfig, parse, Timeout
+from database.mongodb import mongodb_context
+
+
+@validate_call
+def run_server(config: AppConfig | FilePath, **kwargs) -> None:
+    """
+    Runs the API server with all the routes and connection to the database. It first creates a FastAPI
+    application and runs it using `uvicorn <https://www.uvicorn.org/>`_ which is
+    ASGI (Asynchronous Server Gateway Interface) compliant. This function runs the event loop using
+    `asyncio <https://docs.python.org/3/library/asyncio.html>`_ and does not yield!
+
+    Args:
+        config:
+            The configuration of the application which includes both the server and database configurations. In case of
+            a :class:`FilePath`, it should be a valid path to an existing config file which will parsed as a ``.YAML``
+            file.
+
+        **kwargs:
+            The keyword arguments are the same as those accepted by the
+            `FastAPI class <https://fastapi.tiangolo.com/reference/fastapi/#fastapi.FastAPI>`_ and are directly passed
+            to it. These keyword arguments will be first concatenated with the configurations of the API server which
+            are read from the ``config`` argument. The keyword arguments which are passed
+            explicitly to the function take precedence over ``config``.
+    """
+
+    config = parse(config)
+    app = FastAPI(**(config.api_server._asdict() | kwargs))
+    app.include_router(api_router)
+
+    async def _serve():
+        """
+        An auxiliary coroutine to be used in the asynchronous execution of the FastAPI application.
+        """
+        async with mongodb_context(config.database):
+            await uvicorn.Server(
+                config=uvicorn.Config(
+                    host=config.api_server.url.host,
+                    port=config.api_server.url.port,
+                    app=app
+                )
+            ).serve()
+
+    asyncio.run(_serve())
+
+
+@contextmanager
+@validate_call
+def server_process_context(config: AppConfig | FilePath, startup_time: Timeout = 2000):
+    """
+    A synchronous context manager to run the API server in a separate process (non-blocking) using the
+    `multiprocessing <https://docs.python.org/3/library/multiprocessing.html>`_ package. The main use case is envisaged
+    to be in testing environments.
+
+    Args:
+        config:
+            Same as ``config`` argument for :func:`run_server`.
+
+        startup_time:
+            The overall time that is expected for the server and the database connections to be established before
+            actual requests can be sent to the server. For testing purposes ensure that this is sufficiently large so
+            that the tests will not time out.
+    """
+    config = parse(config)
+    process = Process(target=run_server, args=(config,))
+    process.start()
+    try:
+        time.sleep(startup_time / 1000)  # `time.sleep()` expects an argument in seconds, hence the division by 1000.
+        yield process
+    finally:
+        process.terminate()

trolldb/api/api.py

@@ -0,0 +1,107 @@
+"""
+The module which defines error responses that will be returned by the API.
+"""
+
+from collections import OrderedDict
+from typing import Self
+
+from fastapi import status
+from fastapi.responses import PlainTextResponse
+
+
+class FailureResponse:
+    descriptor_delimiter = " |OR| "
+    defaultResponseClass = PlainTextResponse
+
+    def __init__(self, args_dict: dict):
+        self.__dict = OrderedDict(args_dict)
+
+    def __or__(self, other: Self):
+        buff = OrderedDict(self.__dict)
+        for key, value in other.__dict.items():
+            buff[key] = FailureResponse.listify(buff.get(key, []))
+            buff[key].extend(FailureResponse.listify(value))
+        return FailureResponse(buff)
+
+    def __str__(self):
+        return str(self.__dict)
+
+    def fastapi_response(self, status_code: int | None = None):
+        if status_code is None and len(self.__dict) > 1:
+            raise ValueError("In case of multiple response status codes, please provide one.")
+        status_code, content = [(k, v) for k, v in self.__dict.items()][0]
+        try:
+            return FailureResponse.defaultResponseClass(
+                content=FailureResponse.stringify(content),
+                status_code=status_code)
+        except KeyError:
+            raise KeyError(f"No default response found for the given status code: {status_code}")
+
+    @property
+    def fastapi_descriptor(self):
+        return {k: {"description": FailureResponse.stringify(v)} for k, v in self.__dict.items()}
+
+    @staticmethod
+    def listify(item: str | list[str]) -> list[str]:
+        return item if isinstance(item, list) else [item]
+
+    @staticmethod
+    def stringify(item: str | list[str]) -> str:
+        return FailureResponse.descriptor_delimiter.join(FailureResponse.listify(item))
+
+
+class BaseFailureResponses:
+
+    @classmethod
+    def fields(cls):
+        return {k: v for k, v in cls.__dict__.items() if isinstance(v, FailureResponse)}
+
+    @classmethod
+    def union(cls):
+        buff = FailureResponse({})
+        for k, v in cls.fields().items():
+            buff |= v
+        return buff
+
+
+class CollectionFail(BaseFailureResponses):
+    NOT_FOUND = FailureResponse({
+        status.HTTP_404_NOT_FOUND:
+            "Collection name does not exist."
+    })
+
+    WRONG_TYPE = FailureResponse({
+        status.HTTP_422_UNPROCESSABLE_ENTITY:
+            "Collection name must be either a string or None; or both database name and collection name must be None."
+    })
+
+
+class DatabaseFail(BaseFailureResponses):
+    NOT_FOUND = FailureResponse({
+        status.HTTP_404_NOT_FOUND:
+            "Database name does not exist."
+    })
+
+    WRONG_TYPE = FailureResponse({
+        status.HTTP_422_UNPROCESSABLE_ENTITY:
+            "Database name must be either a string or None."
+    })
+
+
+class DocumentsFail(BaseFailureResponses):
+    NOT_FOUND = FailureResponse({
+        status.HTTP_404_NOT_FOUND:
+            "Could not find any document with the given object id."
+    })
+
+
+Database_Collection_Fail = DatabaseFail | CollectionFail
+Database_Collection_Document_Fail = DatabaseFail | CollectionFail | DocumentsFail
+
+database_collection_fail_descriptor = (
+        DatabaseFail.union() | CollectionFail.union()
+).fastapi_descriptor
+
+database_collection_document_fail_descriptor = (
+        DatabaseFail.union() | CollectionFail.union() | DocumentsFail.union()
+).fastapi_descriptor

trolldb/api/errors/__init__.py

@@ -0,0 +1,3 @@
+from .router import api_router
+
+__all__ = ("api_router",)