awips.dataaccess.ModelSounding

Complexity

Total Complexity

32

Size/Duplication

Total Lines	241
Duplicated Lines	72.61 %

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	_SoundingTimeLayer.levels()	11	11	1
A	_SoundingCube.__addItem()	7	7	2
A	_SoundingTimeAndLevelLayer.level()	8	8	1
A	_SoundingTimeLayer.__getitem__()	6	6	2
A	_SoundingTimeAndLevelLayer.time()	8	8	1
A	_SoundingCube.__len__()	2	2	1
A	_SoundingTimeAndLevelLayer.__init__()	4	4	1
A	_SoundingTimeLayer._addItem()	5	5	1
A	_SoundingTimeAndLevelLayer.__getitem__()	2	2	1
A	_SoundingCube.__init__()	9	9	4
A	_SoundingTimeLayer.__init__()	3	3	1
A	_SoundingTimeLayer.time()	8	8	1
A	_SoundingTimeAndLevelLayer.__len__()	2	2	1
A	_SoundingTimeAndLevelLayer.parameters()	8	8	1
A	_SoundingTimeAndLevelLayer._addItem()	2	2	1
A	_SoundingCube.__getitem__()	2	2	1
A	_SoundingTimeLayer.__len__()	2	2	1
A	_SoundingCube.times()	8	8	1

#
# Classes for retrieving soundings based on gridded data from the Data Access
# Framework
#
#
#
#     SOFTWARE HISTORY
#
#    Date            Ticket#       Engineer       Description
#    ------------    ----------    -----------    --------------------------
#    06/24/15         #4480        dgilling       Initial Creation.
#

from collections import defaultdict

Unused defaultdict imported from collections

from shapely.geometry import Point

from awips import DateTimeConverter

Unused DateTimeConverter imported from awips

from awips.dataaccess import DataAccessLayer

from dynamicserialize.dstypes.com.raytheon.uf.common.time import DataTime

Unused DataTime imported from dynamicserialize.dstypes.com.raytheon.uf.common.time

from dynamicserialize.dstypes.com.raytheon.uf.common.dataplugin.level import Level


def getSounding(modelName, weatherElements, levels, samplePoint, timeRange=None):

This code seems to be duplicated in your project.

    """
    Performs a series of Data Access Framework requests to retrieve a sounding object
    based on the specified request parameters.

    Args:
        modelName: the grid model datasetid to use as the basis of the sounding.
        weatherElements: a list of parameters to return in the sounding.
        levels: a list of levels to sample the given weather elements at
        samplePoint: a lat/lon pair to perform the sampling of data at.
        timeRange: (optional) a list of times, or a TimeRange to specify
        which forecast hours to use. If not specified, will default to all forecast hours.

    Returns:
        A _SoundingCube instance, which acts a 3-tiered dictionary, keyed
        by DataTime, then by level and finally by weather element. If no
        data is available for the given request parameters, None is returned.

    """

    (locationNames, parameters, levels, envelope, timeRange) = \
        __sanitizeInputs(modelName, weatherElements, levels, samplePoint, timeRange)

    requestArgs = { 'datatype'      : 'grid',

No space allowed after bracket

                    'locationNames' : locationNames,
                    'parameters'    : parameters,
                    'levels'        : levels,
                    'envelope'      : envelope
                   }

    req = DataAccessLayer.newDataRequest(**requestArgs)
    response = DataAccessLayer.getGeometryData(req, timeRange)
    soundingObject = _SoundingCube(response)

    return soundingObject


def changeEDEXHost(host):
    """
    Changes the EDEX host the Data Access Framework is communicating with.

    Args:
            host: the EDEX host to connect to
    """

    if host:
        DataAccessLayer.changeEDEXHost(str(host))


def __sanitizeInputs(modelName, weatherElements, levels, samplePoint, timeRange):
    locationNames = [str(modelName)]
    parameters = __buildStringList(weatherElements)
    levels = __buildStringList(levels)
    envelope = Point(samplePoint)
    return locationNames, parameters, levels, envelope, timeRange


def __buildStringList(param):
    if __notStringIter(param):

Unnecessary "else" after "return"

        return [str(item) for item in param]
    else:
        return [str(param)]


def __notStringIter(iterable):
    if not isinstance(iterable, str):
        try:
            iter(iterable)
            return True
        except TypeError:
            return False


class _SoundingCube(object):

This code seems to be duplicated in your project.

The variable __class__ seems to be unused.

    """
    The top-level sounding object returned when calling ModelSounding.getSounding.

    This object acts as a 3-tiered dict which is keyed by time then level
    then parameter name. Calling times() will return all valid keys into this
    object.
    """

    def __init__(self, geometryDataObjects):
        self._dataDict = {}
        self._sortedTimes = []
        if geometryDataObjects:
            for geometryData in geometryDataObjects:
                dataTime = geometryData.getDataTime()
                level = geometryData.getLevel()
                for parameter in geometryData.getParameters():
                    self.__addItem(parameter, dataTime, level, geometryData.getNumber(parameter))

    def __addItem(self, parameter, dataTime, level, value):
        timeLayer = self._dataDict.get(dataTime, _SoundingTimeLayer(dataTime))
        self._dataDict[dataTime] = timeLayer
        timeLayer._addItem(parameter, level, value)

It seems like _addItem was declared protected and should not be accessed from this context.

        if dataTime not in self._sortedTimes:
            self._sortedTimes.append(dataTime)
            self._sortedTimes.sort()

    def __getitem__(self, key):
        return self._dataDict[key]

    def __len__(self):
        return len(self._dataDict)

    def times(self):
        """
        Returns the valid times for this sounding.

        Returns:
            A list containing the valid DataTimes for this sounding in order.
        """
        return self._sortedTimes


class _SoundingTimeLayer(object):

This code seems to be duplicated in your project.

The variable __class__ seems to be unused.

    """
    The second-level sounding object returned when calling ModelSounding.getSounding.

    This object acts as a 2-tiered dict which is keyed by level then parameter
    name. Calling levels() will return all valid keys into this
    object. Calling time() will return the DataTime for this particular layer.
    """

    def __init__(self, dataTime):
        self._dataTime = dataTime
        self._dataDict = {}

    def _addItem(self, parameter, level, value):
        asString = str(level)
        levelLayer = self._dataDict.get(asString, _SoundingTimeAndLevelLayer(self._dataTime, asString))

This line is too long as per the coding-style (103/100).

        levelLayer._addItem(parameter, value)

It seems like _addItem was declared protected and should not be accessed from this context.

        self._dataDict[asString] = levelLayer

    def __getitem__(self, key):
        asString = str(key)
        if asString in self._dataDict:
            return self._dataDict[asString]
        else:
            raise KeyError("Level " + str(key) + " is not a valid level for this sounding.")

    def __len__(self):
        return len(self._dataDict)

    def time(self):
        """
        Returns the DataTime for this sounding cube layer.

        Returns:
            The DataTime for this sounding layer.
        """
        return self._dataTime

    def levels(self):
        """
        Returns the valid levels for this sounding.

        Returns:
            A list containing the valid levels for this sounding in order of
            closest to surface to highest from surface.
        """
        sortedLevels = [Level(level) for level in list(self._dataDict.keys())]
        sortedLevels.sort()
        return [str(level) for level in sortedLevels]


class _SoundingTimeAndLevelLayer(object):

This code seems to be duplicated in your project.

The variable __class__ seems to be unused.

    """
    The bottom-level sounding object returned when calling ModelSounding.getSounding.

    This object acts as a dict which is keyed by parameter name. Calling
    parameters() will return all valid keys into this object. Calling time()
    will return the DataTime for this particular layer. Calling level() will
    return the level for this layer.
    """

    def __init__(self, time, level):
        self._time = time
        self._level = level
        self._parameters = {}

    def _addItem(self, parameter, value):
        self._parameters[parameter] = value

    def __getitem__(self, key):
        return self._parameters[key]

    def __len__(self):
        return len(self._parameters)

    def level(self):
        """
        Returns the level for this sounding cube layer.

        Returns:
            The level for this sounding layer.
        """
        return self._level

    def parameters(self):
        """
        Returns the valid parameters for this sounding.

        Returns:
            A list containing the valid parameter names.
        """
        return list(self._parameters.keys())

    def time(self):
        """
        Returns the DataTime for this sounding cube layer.

        Returns:
            The DataTime for this sounding layer.
        """
        return self._time