ImageStore

Complexity

Total Complexity

8

Size/Duplication

Total Lines	34
Duplicated Lines	0 %

Test Coverage

Coverage

87.5%

4 Methods

Rating	Name	Duplication	Size	Complexity
A	exists()	0	4	1
A	__init__()	0	3	1
A	latest()	0	3	1
B	create()	0	17	5

# pylint: disable=no-member

Locally disabling no-member (E1101)

This module should have a docstring.

import os
import logging

import sqlalchemy as sa

The import sqlalchemy could not be resolved.

from ..extensions import db

log = logging.getLogger(__name__)

The name log does not conform to the constant naming conventions ((([A-Z_][A-Z0-9_]*)|(__.*__))$).

class WordModel(db.Model):

This class has no __init__ method.

This class should have a docstring.

    __tablename__ = 'words'

    id = sa.Column(sa.String, primary_key=True, nullable=False)

The name id does not conform to the class attribute naming conventions (([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$).

    meme_id = sa.Column(sa.String, nullable=False)
    occurances = sa.Column(sa.Integer)

    def __repr__(self):
        return "<Word(id='%s', meme_id='%s', occurances='%s')>" \
            % (self.id, self.meme_id, self.occurances)


class ImageModel:

This class should have a docstring.

    def __init__(self, image):
        self._word_models = {}
        self._words = []
        self.key = image.template.key

        # append all the individual words into an array
        for line in image.text.lines:
            self._words += line.lower().split(' ')

        # look-up the word from the database, count the
        # occurances in this particular set of text
        for word in self._words:
            # is there no entry? should we query for one
            # or create a new one?
            if not self._word_models.get(word):
                model = (
                    db.session.query(WordModel)
                    .filter(WordModel.id == word)
                    .first()
                )

                # doesn't exist, create a new model
                if not model:
                    model = WordModel(id=word, meme_id=self.key, occurances=0)

                model.occurances += 1
                self._word_models[word] = model

            else:
                self._word_models[word].occurances += 1

        # save all the updated occurance counts
        for key in self._word_models:
            if self._word_models[key]:
                db.session.add(self._word_models[key])
        db.session.commit()


class ImageStore:

This class should have a docstring.

    LATEST = "latest.jpg"

    def __init__(self, root, config):
        self.root = root
        self.regenerate_images = config.get('REGENERATE_IMAGES', False)

    @property
    def latest(self):

This method should have a docstring.

        return os.path.join(self.root, self.LATEST)

    def exists(self, image):

This method should have a docstring.

        image.root = self.root
        # TODO: add a way to determine if the styled image was already generated

TODO and FIXME comments should generally be avoided.

        return os.path.isfile(image.path) and not image.style

    def create(self, image):

This method should have a docstring.

        if self.exists(image) and not self.regenerate_images:
            return

        try:
            ImageModel(image)
        except ImportError:
            log.warning("Unable to store models on this machine")

        image.root = self.root
        image.generate()

        try:
            os.remove(self.latest)
        except IOError:
            pass
        os.symlink(image.path, self.latest)