MongoRepository

Complexity

Total Complexity

36

Size/Duplication

Total Lines	174
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	knows()	0	7	1
A	byLocations()	0	3	2
A	__init__()	0	7	1
A	knowsByLocation()	0	8	1
A	byLocation()	0	17	2
A	add()	0	7	1
A	all()	0	8	2
A	updateApproval()	0	3	1
A	getSeries()	0	17	2
A	knowsSeries()	0	14	2
A	update()	0	8	1
A	byId()	0	6	2
A	latest()	0	3	2
A	byParents()	0	4	2
A	statistics()	0	13	2
A	inflate()	0	7	3
A	deflate()	0	8	3
A	search()	0	7	3
A	inquire()	0	7	3

import pymongo, copy, bson
from datetime import timedelta
from niprov.dependencies import Dependencies


class MongoRepository(object):

    def __init__(self, dependencies=Dependencies()):
        self.config = dependencies.getConfiguration()
        self.factory = dependencies.getFileFactory()
        self.pictures = dependencies.getPictureCache()
        self.listener = dependencies.getListener()
        client = pymongo.MongoClient(self.config.database_url)
        self.db = client.get_default_database()

    def byLocation(self, locationString):
        """Get the provenance for a file at the given location. 

        In the case of a dicom series, this returns the provenance for the 
        series.

        Args:
            locationString (str): Location of the image file.

        Returns:
            dict: Provenance for one image file.
        """
        record = self.db.provenance.find_one({'location':locationString})
        if record is None:
            self.listener.unknownFile(locationString)
            return
        return self.inflate(record)

    def byLocations(self, listOfLocations):
        records = self.db.provenance.find({'location':{'$in':listOfLocations}})
        return [self.inflate(record) for record in records]

    def knowsByLocation(self, locationString):
        """Whether the file at this location has provenance associated with it.

        Returns:
            bool: True if provenance is available for that path.
        """
        return self.db.provenance.find_one(
            {'location':locationString}) is not None

    def knows(self, image):
        """Whether this file has provenance associated with it.

        Returns:
            bool: True if provenance is available for this image.
        """
        return self.knowsByLocation(image.location.toString())

    def getSeries(self, image):
        """Get the object that carries provenance for the series that the image 
        passed is in. 

        Args:
            image (:class:`.DicomFile`): File that is part of a series.

        Returns:
            :class:`.DicomFile`: Image object that caries provenance for 
                         the series.
        """
        seriesUid = image.getSeriesId()
        record = self.db.provenance.find_one({'seriesuid':seriesUid})
        if record is None:
            self.listener.unknownFile('seriesuid: '+str(seriesUid))
            return
        return self.inflate(record)

    def knowsSeries(self, image):
        """Whether this file is part of a series for which provenance 
        is available.

        Args:
            image (:class:`.BaseFile`): File for which the series is sought.

        Returns:
            bool: True if provenance is available for this series.
        """
        seriesUid = image.getSeriesId()
        if seriesUid is None:
            return False
        return self.db.provenance.find_one({'seriesuid':seriesUid}) is not None

    def add(self, image):
        """Add the provenance for one file to storage.

        Args:
            image (:class:`.BaseFile`): Image file to store.
        """
        self.db.provenance.insert_one(self.deflate(image))

    def update(self, image):
        """Save changed provenance for this file..

        Args:
            image (:class:`.BaseFile`): Image file that has changed.
        """
        self.db.provenance.update({'location':image.location.toString()}, 
            self.deflate(image))

    def updateApproval(self, locationString, approvalStatus):
        self.db.provenance.update({'location':locationString}, 
            {'$set': {'approval': approvalStatus}})

    def all(self):
        """Retrieve all known provenance from storage.

        Returns:
            list: List of provenance for known files.
        """
        records = self.db.provenance.find()
        return [self.inflate(record) for record in records]

    def latest(self):
        records = self.db.provenance.find().sort('added', -1).limit(20)
        return [self.inflate(record) for record in records]

    def statistics(self):
        grps = self.db.provenance.aggregate(
           [{'$group':
                 {
                   '_id': None,
                   'totalsize': { '$sum': '$size' },
                   'count': { '$sum': 1 }
                 }
            }])
        groups = list(grps)
        if len(list(groups)) == 0:
            return {'count':0}
        return list(groups)[0]

    def byId(self, uid):
        record = self.db.provenance.find_one({'id':uid})
        if record is None:
            self.listener.unknownFile('id: '+str(uid))
            return
        return self.inflate(record)

    def byParents(self, listOfParentLocations):
        records = self.db.provenance.find({'parents':{
            '$in':listOfParentLocations}})
        return [self.inflate(record) for record in records]

    def inquire(self, query):
        field = query.getFields()[0]
        if field.all:
            records = self.db.provenance.distinct(field.name)
        else:
            records = self.db.provenance.find({field.name:field.value})
        return [self.inflate(record) for record in records]

    def search(self, text):
        searchfields = ['location','user','subject','project','protocol',
                  'transformation','technique','modality']
        indexspec = [(field, pymongo.TEXT) for field in searchfields]
        self.db.provenance.create_index(indexspec)
        records = self.db.provenance.find({'$text':{'$search': text}})
        return [self.inflate(record) for record in records]

    def deflate(self, img):
        record = copy.deepcopy(img.provenance)
        if 'duration' in record:
            record['duration'] = record['duration'].total_seconds()
        snapshotData = self.pictures.getBytes(for_=img)
        if snapshotData:
            record['_snapshot-data'] = bson.Binary(snapshotData)
        return record

    def inflate(self, record):
        if 'duration' in record:
            record['duration'] = timedelta(seconds=record['duration'])
        img = self.factory.fromProvenance(record)
        if '_snapshot-data' in record:
            self.pictures.keep(record['_snapshot-data'], for_=img)
        return img