AnnifBackend

Complexity

Total Complexity

10

Size/Duplication

Total Lines	50
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__init__()	0	7	1
A	_get_datadir()	0	6	2
A	load_subjects()	0	3	1
A	debug()	0	3	1
A	warning()	0	3	1
A	analyze()	0	7	2
A	_analyze()	0	5	1
A	info()	0	3	1

"""Common functionality for backends."""

import abc
import os
import os.path
import annif

The import annif seems to be unused.

from annif import logger


class AnnifBackend(metaclass=abc.ABCMeta):

The variable __class__ seems to be unused.

    """Base class for Annif backends that perform analysis. The
    non-implemented methods should be overridden in subclasses."""

    name = None

    def __init__(self, backend_id, params, datadir):
        """Initialize backend with specific parameters. The
        parameters are a dict. Keys and values depend on the specific
        backend type."""
        self.backend_id = backend_id
        self.params = params
        self._datadir = os.path.join(datadir, 'backends', self.backend_id)

    def _get_datadir(self):
        """return the path of the directory where this backend can store its
        data files"""
        if not os.path.exists(self._datadir):
            os.makedirs(self._datadir)
        return self._datadir

    def load_subjects(self, subjects, analyzer):
        """load the given subjects analyzed using the given analyzer"""
        pass  # default is to do nothing, subclasses may override

    @abc.abstractmethod
    def _analyze(self, text, params):
        """This method should implemented by backends. It implements
        the analyze functionality, with pre-processed parameters."""
        pass

    def analyze(self, text, params=None):
        """Analyze some input text and return a list of subjects represented
        as a list of AnalysisHit objects."""
        beparams = dict(self.params)
        if params is not None:
            beparams.update(params)
        return self._analyze(text, params=beparams)

    def debug(self, message):
        """Log a debug message from this backend"""
        logger.debug("Backend {}: {}".format(self.backend_id, message))

Use formatting in logging functions and pass the parameters as arguments

    def info(self, message):
        """Log an info message from this backend"""
        logger.info("Backend {}: {}".format(self.backend_id, message))

Use formatting in logging functions and pass the parameters as arguments

    def warning(self, message):
        """Log a warning message from this backend"""
        logger.warning("Backend {}: {}".format(self.backend_id, message))

Use formatting in logging functions and pass the parameters as arguments