Source code for memote.suite.results.sql_result_manager

# -*- coding: utf-8 -*-

# Copyright 2017 Novo Nordisk Foundation Center for Biosustainability,
# Technical University of Denmark.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Provide a memote result manager that is git aware and uses a SQL database."""

from __future__ import absolute_import

import logging

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm.exc import NoResultFound

from memote.suite.results.models import Base, Result
from memote.suite.results.repo_result_manager import RepoResultManager
from memote.suite.results.result import MemoteResult


__all__ = ("SQLResultManager",)

LOGGER = logging.getLogger(__name__)

Session = sessionmaker()


class SQLResultManager(RepoResultManager):
    """Manage storage of results to a database."""

    def __init__(self, **kwargs):
        """
        Initialize the repository aware database storage manager.

        Parameters
        ----------
        location : str
            A Database connection URL.

        """
        super(SQLResultManager, self).__init__(**kwargs)
        self._backend = create_engine(self._backend)
        # Create the database and tables if it doesn't exist.
        Base.metadata.create_all(self._backend, checkfirst=True)
        self.session = Session(bind=self._backend)

    def store(self, result, commit=None, **kwargs):
        """
        Store a result in a JSON file attaching git meta information.

        Parameters
        ----------
        result : memote.MemoteResult
            The dictionary structure of results.
        commit : str, optional
            Unique hexsha of the desired commit.
        kwargs :
            Passed to parent function.

        """
        git_info = self.record_git_info(commit)
        try:
            row = self.session.query(Result).filter_by(hexsha=git_info.hexsha).one()
            LOGGER.info("Updating result '%s'.", git_info.hexsha)
            row.memote_result = result
        except NoResultFound:
            row = Result(memote_result=result)
            LOGGER.info("Storing result '%s'.", git_info.hexsha)
        row.hexsha = git_info.hexsha
        row.author = git_info.author
        row.email = git_info.email
        row.authored_on = git_info.authored_on
        self.session.add(row)
        self.session.commit()

    def load(self, commit=None):
        """Load a result from the database."""
        git_info = self.record_git_info(commit)
        LOGGER.info("Loading result from '%s'.", git_info.hexsha)
        result = MemoteResult(
            self.session.query(Result.memote_result)
            .filter_by(hexsha=git_info.hexsha)
            .one()
            .memote_result
        )
        # Add git info so the object is equivalent to the one returned by the
        #  RepoResultManager.
        self.add_git(result.meta, git_info)
        return result