bika.lims.adapters.dynamicresultsrange.DynamicResultsRange.get_results_range() - Code Metrics - Inspection of "Update CHANGES.rst" - senaite/senaite.core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 65c723...b6585a )

by Jordi

created 2020-01-28 12:14 UTC

DynamicResultsRange.get_results_range() C

↳ Parent: bika.lims.adapters.dynamicresultsrange

Complexity

Conditions

Size

Total Lines	55
Code Lines	27

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	27
dl	0
loc	55
rs	5.9999
c	0
b	0
f	0
cc	10
nop	1

How to fix Long Method Complexity

Long Method

Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.

For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.

Commonly applied refactorings include:

If many parameters/temporary variables are present:
- Replace temporary variables with Query
- Introduce parameter object; often combined with preserve whole object
- If the above two are insufficient: Replace method with method object
If you have long conditionals: Decompose Conditional
Otherwise: Extract method

Complexity

Complex classes like bika.lims.adapters.dynamicresultsrange.DynamicResultsRange.get_results_range() often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

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

from bika.lims import api
from bika.lims.interfaces import IDynamicResultsRange
from zope.interface import implementer

marker = object()

DEFAULT_RANGE_KEYS = [
    "min",
    "warn_min",
    "min_operator",
    "minpanic",
    "max",
    "warn_max",
    "max",
    "maxpanic",
    "error",
]


@implementer(IDynamicResultsRange)
class DynamicResultsRange(object):
    """Default Dynamic Results Range Adapter
    """

    def __init__(self, analysis):
        self.analysis = analysis
        self.analysisrequest = analysis.getRequest()
        self.specification = self.analysisrequest.getSpecification()
        self.dynamicspec = None
        if self.specification:
            self.dynamicspec = self.specification.getDynamicAnalysisSpec()

    @property
    def keyword(self):
        """Analysis Keyword
        """
        return self.analysis.getKeyword()

    @property
    def range_keys(self):
        """The keys of the result range dict
        """
        if not self.specification:
            return DEFAULT_RANGE_KEYS
        # return the subfields of the specification
        return self.specification.getField("ResultsRange").subfields

    def convert(self, value):
        # convert referenced UIDs to the Title
        if api.is_uid(value):
            obj = api.get_object_by_uid(value)
            return api.get_title(obj)
        return value

    def get_match_data(self):
        """Returns a fieldname -> value mapping of context data

        The fieldnames are selected from the column names of the dynamic
        specifications file. E.g. the column "Method" of teh specifications
        file will lookup the value (title) of the Analysis and added to the
        mapping like this: `{"Method": "Method-1"}`.

        :returns: fieldname -> value mapping
        :rtype: dict
        """
        data = {}

        # Lookup the column names on the Analysis and the Analysis Request
        for column in self.dynamicspec.get_header():
            an_value = getattr(self.analysis, column, marker)
            ar_value = getattr(self.analysisrequest, column, marker)
            if an_value is not marker:
                data[column] = self.convert(an_value)
            elif ar_value is not marker:
                data[column] = self.convert(ar_value)

        return data

    def get_results_range(self):
        """Return the dynamic results range

        The returning dicitionary should containe at least the `min` and `max`
        values to override the ResultsRangeDict data.

        :returns: An `IResultsRangeDict` compatible dict
        :rtype: dict
        """
        if self.dynamicspec is None:
            return {}
        # A matching Analysis Keyword is mandatory for any further matches
        keyword = self.analysis.getKeyword()
        by_keyword = self.dynamicspec.get_by_keyword()
        # Get all specs (rows) from the Excel with the same Keyword
        specs = by_keyword.get(keyword)
        if not specs:
            return {}

        # Generate a match data object, which match both the column names and
        # the field names of the Analysis.
        match_data = self.get_match_data()

        rr = {}

        # Iterate over the rows and return the first where **all** values match
        # with the analysis' values
        for spec in specs:
            skip = False

            for k, v in match_data.items():
                # break if the values do not match
                if v != spec[k]:
                    skip = True
                    break

            # skip the whole specification row
            if skip:
                continue

            # at this point we have a match, update the results range dict
            for key in self.range_keys:
                value = spec.get(key, marker)
                # skip if the range key is not set in the Excel
                if value is marker:
                    continue
                # skip if the value is not floatable
                if not api.is_floatable(value):
                    continue
                # set the range value
                rr[key] = value
            # return the updated result range
            return rr

        return rr

    def __call__(self):
        return self.get_results_range()


1			# -- coding: utf-8 --
2
3			from bika.lims import api
4			from bika.lims.interfaces import IDynamicResultsRange
5			from zope.interface import implementer
6
7			marker = object()
8
9			DEFAULT_RANGE_KEYS = [
10			"min",
11			"warn_min",
12			"min_operator",
13			"minpanic",
14			"max",
15			"warn_max",
16			"max",
17			"maxpanic",
18			"error",
19			]
20
21
22			@implementer(IDynamicResultsRange)
23			class DynamicResultsRange(object):
24			"""Default Dynamic Results Range Adapter
25			"""
26
27			def __init__(self, analysis):
28			self.analysis = analysis
29			self.analysisrequest = analysis.getRequest()
30			self.specification = self.analysisrequest.getSpecification()
31			self.dynamicspec = None
32			if self.specification:
33			self.dynamicspec = self.specification.getDynamicAnalysisSpec()
34
35			@property
36			def keyword(self):
37			"""Analysis Keyword
38			"""
39			return self.analysis.getKeyword()
40
41			@property
42			def range_keys(self):
43			"""The keys of the result range dict
44			"""
45			if not self.specification:
46			return DEFAULT_RANGE_KEYS
47			# return the subfields of the specification
48			return self.specification.getField("ResultsRange").subfields
49
50			def convert(self, value):
51			# convert referenced UIDs to the Title
52			if api.is_uid(value):
53			obj = api.get_object_by_uid(value)
54			return api.get_title(obj)
55			return value
56
57			def get_match_data(self):
58			"""Returns a fieldname -> value mapping of context data
59
60			The fieldnames are selected from the column names of the dynamic
61			specifications file. E.g. the column "Method" of teh specifications
62			file will lookup the value (title) of the Analysis and added to the
63			mapping like this: `{"Method": "Method-1"}`.
64
65			:returns: fieldname -> value mapping
66			:rtype: dict
67			"""
68			data = {}
69
70			# Lookup the column names on the Analysis and the Analysis Request
71			for column in self.dynamicspec.get_header():
72			an_value = getattr(self.analysis, column, marker)
73			ar_value = getattr(self.analysisrequest, column, marker)
74			if an_value is not marker:
75			data[column] = self.convert(an_value)
76			elif ar_value is not marker:
77			data[column] = self.convert(ar_value)
78
79			return data
80
81			def get_results_range(self):
82			"""Return the dynamic results range
83
84			The returning dicitionary should containe at least the `min` and `max`
85			values to override the ResultsRangeDict data.
86
87			:returns: An `IResultsRangeDict` compatible dict
88			:rtype: dict
89			"""
90			if self.dynamicspec is None:
91			return {}
92			# A matching Analysis Keyword is mandatory for any further matches
93			keyword = self.analysis.getKeyword()
94			by_keyword = self.dynamicspec.get_by_keyword()
95			# Get all specs (rows) from the Excel with the same Keyword
96			specs = by_keyword.get(keyword)
97			if not specs:
98			return {}
99
100			# Generate a match data object, which match both the column names and
101			# the field names of the Analysis.
102			match_data = self.get_match_data()
103
104			rr = {}
105
106			# Iterate over the rows and return the first where all values match
107			# with the analysis' values
108			for spec in specs:
109			skip = False
110
111			for k, v in match_data.items():
112			# break if the values do not match
113			if v != spec[k]:
114			skip = True
115			break
116
117			# skip the whole specification row
118			if skip:
119			continue
120
121			# at this point we have a match, update the results range dict
122			for key in self.range_keys:
123			value = spec.get(key, marker)
124			# skip if the range key is not set in the Excel
125			if value is marker:
126			continue
127			# skip if the value is not floatable
128			if not api.is_floatable(value):
129			continue
130			# set the range value
131			rr[key] = value
132			# return the updated result range
133			return rr
134
135			return rr
136
137			def __call__(self):
138			return self.get_results_range()
139

senaite / senaite.core

Push — master ( 65c723...b6585a )

DynamicResultsRange.get_results_range() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like