def __call__(self, context):
encoders = [
encoder[0]
for encoder in getAdapters((pseudoassignment, ), ISteamer)
]
terms = [SimpleTerm(encoder, encoder) for encoder in encoders]
return SimpleVocabulary(terms)
def is_out_of_range(brain_or_object, result=_marker):
"""Checks if the result for the analysis passed in is out of range and/or
out of shoulders range.
min max
warn min max warn
·········|---------------|=====================|---------------|·········
----- out-of-range -----><----- in-range ------><----- out-of-range -----
<-- shoulder --><----- in-range ------><-- shoulder -->
:param brain_or_object: A single catalog brain or content object
:param result: Tentative result. If None, use the analysis result
:type brain_or_object: ATContentType/DexterityContentType/CatalogBrain
:returns: Tuple of two elements. The first value is `True` if the result is
out of range and `False` if it is in range. The second value is `True` if
the result is out of shoulder range and `False` if it is in shoulder range
:rtype: (bool, bool)
"""
analysis = api.get_object(brain_or_object)
if not IAnalysis.providedBy(analysis) and \
not IReferenceAnalysis.providedBy(analysis):
api.fail("{} is not supported. Needs to be IAnalysis or "
"IReferenceAnalysis".format(repr(analysis)))
if result is _marker:
result = api.safe_getattr(analysis, "getResult", None)
if result in [None, '']:
# Empty result
return False, False
if IDuplicateAnalysis.providedBy(analysis):
# Result range for duplicate analyses is calculated from the original
# result, applying a variation % in shoulders. If the analysis has
# result options enabled or string results enabled, system returns an
# empty result range for the duplicate: result must match %100 with the
# original result
original = analysis.getAnalysis()
original_result = original.getResult()
# Does original analysis have a valid result?
if original_result in [None, '']:
return False, False
# Does original result type matches with duplicate result type?
if api.is_floatable(result) != api.is_floatable(original_result):
return True, True
# Does analysis has result options enabled or non-floatable?
if analysis.getResultOptions() or not api.is_floatable(original_result):
# Let's always assume the result is 'out from shoulders', cause we
# consider the shoulders are precisely the duplicate variation %
out_of_range = original_result != result
return out_of_range, out_of_range
elif not api.is_floatable(result):
# A non-duplicate with non-floatable result. There is no chance to know
# if the result is out-of-range
return False, False
# Convert result to a float
result = api.to_float(result)
# Note that routine analyses, duplicates and reference analyses all them
# implement the function getResultRange:
# - For routine analyses, the function returns the valid range based on the
# specs assigned during the creation process.
# - For duplicates, the valid range is the result of the analysis the
# the duplicate was generated from +/- the duplicate variation.
# - For reference analyses, getResultRange returns the valid range as
# indicated in the Reference Sample from which the analysis was created.
result_range = api.safe_getattr(analysis, "getResultsRange", None)
if not result_range:
# No result range defined or the passed in object does not suit
return False, False
# Maybe there is a custom adapter
adapters = getAdapters((analysis,), IResultOutOfRange)
for name, adapter in adapters:
ret = adapter(result=result, specification=result_range)
if not ret or not ret.get('out_of_range', False):
continue
if not ret.get('acceptable', True):
# Out of range + out of shoulders
return True, True
# Out of range, but in shoulders
return True, False
result_range = ResultsRangeDict(result_range)
# The assignment of result as default fallback for min and max guarantees
# the result will be in range also if no min/max values are defined
specs_min = api.to_float(result_range.min, result)
specs_max = api.to_float(result_range.max, result)
in_range = False
min_operator = result_range.min_operator
if min_operator == "geq":
in_range = result >= specs_min
else:
in_range = result > specs_min
max_operator = result_range.max_operator
if in_range:
if max_operator == "leq":
in_range = result <= specs_max
else:
in_range = result < specs_max
# If in range, no need to check shoulders
if in_range:
return False, False
# Out of range, check shoulders. If no explicit warn_min or warn_max have
# been defined, no shoulders must be considered for this analysis. Thus, use
# specs' min and max as default fallback values
warn_min = api.to_float(result_range.warn_min, specs_min)
warn_max = api.to_float(result_range.warn_max, specs_max)
in_shoulder = warn_min <= result <= warn_max
return True, not in_shoulder
def __call__(self, context):
encoders = [encoder[0]
for encoder
in getAdapters((pseudoassignment,), ISteamer)]
terms = [SimpleTerm(encoder, encoder) for encoder in encoders]
return SimpleVocabulary(terms)
def is_out_of_range(brain_or_object, result=_marker):
"""Checks if the result for the analysis passed in is out of range and/or
out of shoulders range.
min max
warn min max warn
·········|---------------|=====================|---------------|·········
----- out-of-range -----><----- in-range ------><----- out-of-range -----
<-- shoulder --><----- in-range ------><-- shoulder -->
:param brain_or_object: A single catalog brain or content object
:param result: Tentative result. If None, use the analysis result
:type brain_or_object: ATContentType/DexterityContentType/CatalogBrain
:returns: Tuple of two elements. The first value is `True` if the result is
out of range and `False` if it is in range. The second value is `True` if
the result is out of shoulder range and `False` if it is in shoulder range
:rtype: (bool, bool)
"""
analysis = api.get_object(brain_or_object)
if not IAnalysis.providedBy(analysis) and \
not IReferenceAnalysis.providedBy(analysis):
api.fail("{} is not supported. Needs to be IAnalysis or "
"IReferenceAnalysis".format(repr(analysis)))
if result is _marker:
result = api.safe_getattr(analysis, "getResult", None)
if not api.is_floatable(result):
# Result is empty/None or not a valid number
return False, False
result = api.to_float(result)
# Note that routine analyses, duplicates and reference analyses all them
# implement the function getResultRange:
# - For routine analyses, the function returns the valid range based on the
# specs assigned during the creation process.
# - For duplicates, the valid range is the result of the analysis the
# the duplicate was generated from +/- the duplicate variation.
# - For reference analyses, getResultRange returns the valid range as
# indicated in the Reference Sample from which the analysis was created.
result_range = api.safe_getattr(analysis, "getResultsRange", None)
if not result_range:
# No result range defined or the passed in object does not suit
return False, False
# Maybe there is a custom adapter
adapters = getAdapters((analysis, ), IResultOutOfRange)
for name, adapter in adapters:
ret = adapter(result=result, specification=result_range)
if not ret or not ret.get('out_of_range', False):
continue
if not ret.get('acceptable', True):
# Out of range + out of shoulders
return True, True
# Out of range, but in shoulders
return True, False
# The assignment of result as default fallback for min and max guarantees
# the result will be in range also if no min/max values are defined
specs_min = api.to_float(result_range.get('min', result), result)
specs_max = api.to_float(result_range.get('max', result), result)
if specs_min <= result <= specs_max:
# In range, no need to check shoulders
return False, False
# Out of range, check shoulders. If no explicit warn_min or warn_max have
# been defined, no shoulders must be considered for this analysis. Thus, use
# specs' min and max as default fallback values
warn_min = api.to_float(result_range.get('warn_min', specs_min), specs_min)
warn_max = api.to_float(result_range.get('warn_max', specs_max), specs_max)
in_shoulder = warn_min <= result <= warn_max
return True, not in_shoulder