Gets the metadata for the lowest numeric score.

        return: (osid.Metadata) - metadata for the lowest numeric score
        *compliance: mandatory -- This method must be implemented.*
329088
def get_numeric_score_increment_metadata(self):
        
        # Implemented from template for osid.resource.ResourceForm.get_group_metadata_template
        metadata = dict(self._mdata['numeric_score_increment'])
        metadata.update({'existing_decimal_values': self._my_map['numericScoreIncrement']})
        return Metadata(**metadata)
928304
def get_score_metadata(self):
        
        # Implemented from template for osid.resource.ResourceForm.get_group_metadata_template
        metadata = dict(self._mdata['score'])
        metadata.update({'existing_decimal_values': self._my_map['score']})
        return Metadata(**metadata)
874485
def _init_metadata(self, **kwargs):
        """"""
        osid_objects.OsidObjectForm._init_metadata(self, **kwargs)
        self._output_score_default = self._mdata['output_score']['default_decimal_values'][0]
        self._input_score_end_range_default = self._mdata['input_score_end_range']['default_decimal_values'][0]
        self._input_score_start_range_default = self._mdata['input_score_start_range']['default_decimal_values'][0]
489248
def get_grade_system_mdata():
    """"""
    return {
        'numeric_score_increment': {
            'element_label': {
                'text': 'numeric score increment',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'instructions': {
                'text': 'enter a decimal value.',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'required': False,
            'read_only': False,
            'linked': False,
            'array': False,
            'default_decimal_values': [None],
            'syntax': 'DECIMAL',
            'decimal_scale': None,
            'minimum_decimal': None,
            'maximum_decimal': None,
            'decimal_set': [],
        },
        'lowest_numeric_score': {
            'element_label': {
                'text': 'lowest numeric score',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'instructions': {
                'text': 'enter a decimal value.',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'required': False,
            'read_only': False,
            'linked': False,
            'array': False,
            'default_decimal_values': [None],
            'syntax': 'DECIMAL',
            'decimal_scale': None,
            'minimum_decimal': None,
            'maximum_decimal': None,
            'decimal_set': [],
        },
        'based_on_grades': {
            'element_label': {
                'text': 'based on grades',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'instructions': {
                'text': 'enter either true or false.',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'required': False,
            'read_only': False,
            'linked': False,
            'array': False,
            'default_boolean_values': [None],
            'syntax': 'BOOLEAN',
        },
        'highest_numeric_score': {
            'element_label': {
                'text': 'highest numeric score',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'instructions': {
                'text': 'enter a decimal value.',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'required': False,
            'read_only': False,
            'linked': False,
            'array': False,
            'default_decimal_values': [None],
            'syntax': 'DECIMAL',
            'decimal_scale': None,
            'minimum_decimal': None,
            'maximum_decimal': None,
            'decimal_set': [],
        },
    }
1305366
def _init_metadata(self, **kwargs):
        """"""
        osid_objects.OsidObjectForm._init_metadata(self, **kwargs)
        self._numeric_score_increment_default = self._mdata['numeric_score_increment']['default_decimal_values'][0]
        self._lowest_numeric_score_default = self._mdata['lowest_numeric_score']['default_decimal_values'][0]
        self._based_on_grades_default = self._mdata['based_on_grades']['default_boolean_values'][0]
        self._highest_numeric_score_default = self._mdata['highest_numeric_score']['default_decimal_values'][0]
1177516
def GetMetricMetadata():
  """"""
  return [
      stats_utils.CreateCounterMetadata("grr_client_unknown"),
      stats_utils.CreateCounterMetadata("grr_decoding_error"),
      stats_utils.CreateCounterMetadata("grr_decryption_error"),
      stats_utils.CreateCounterMetadata("grr_authenticated_messages"),
      stats_utils.CreateCounterMetadata("grr_unauthenticated_messages"),
      stats_utils.CreateCounterMetadata("grr_rsa_operations"),
      stats_utils.CreateCounterMetadata(
          "grr_encrypted_cipher_cache", fields=[("type", str)]),
  ]
1139826
def metadata(self):
        
        # Check exceptional case: return none if no metadata
        if not self._operation.HasField('metadata'):
            return None

        # Return expected metadata
        return _from_any(self._metadata_type, self._operation.metadata)
909717
def range_by_score(self, min, max, num=None, withscores=False):
        """"""
        return self.client.zrangebyscore(self.name, min, max, num=num,
                                         withscores=withscores)
245587
def metadata(abbr, __metadata=__metadata):
    
    # This data should change very rarely and is queried very often so
    # cache it here
    abbr = abbr.lower()
    if abbr in __metadata:
        return __metadata[abbr]
    rv = db.metadata.find_one({'_id': abbr})

    __metadata[abbr] = rv
    return rv
137639
def minimal_payload(self):
        
        payload_dict = self.__dict__
        payload_dict.pop("api_version", None)
        return util._make_minimal(payload_dict)
90012
def get_count(self):
        
        params = self.get_params()
        params["offset"] = self.low_mark
        params["limit"] = 1

        r = self.resource._meta.api.http_resource("GET", self.resource._meta.resource_name, params=params)
        data = self.resource._meta.api.resource_deserialize(r.text)

        number = data["meta"]["total_count"]

        # Apply offset and limit constraints manually, since using limit/offset
        # in the API doesn't change the total_count output.
        number = max(0, number - self.low_mark)
        if self.high_mark is not None:
            number = min(number, self.high_mark - self.low_mark)

        return number
438564
def _maxscore(self):
        
        total = 0
        lowtot= 0
        for lli in self.ll:
            total = total + max(lli.values())
            lowtot= lowtot+ min(lli.values())
        self.maxscore = total
        self.minscore = lowtot
1151511
async def zremrangebyscore(self, name, min, max):
        
        return await self.execute_command('ZREMRANGEBYSCORE', name, min, max)
50943
def get_score_system_id(self):
        
        # Implemented from template for osid.resource.Resource.get_avatar_id_template
        if not bool(self._my_map['scoreSystemId']):
            raise errors.IllegalState('this AssessmentOffered has no score_system')
        else:
            return Id(self._my_map['scoreSystemId'])
1219353
def _compute_metadata_from_readers(self):
        """"""
        mda = {'sensor': self._get_sensor_names()}

        # overwrite the request start/end times with actual loaded data limits
        if self.readers:
            mda['start_time'] = min(x.start_time
                                    for x in self.readers.values())
            mda['end_time'] = max(x.end_time
                                  for x in self.readers.values())
        return mda
43367
def get_assessments_metadata(self):
        
        # Implemented from template for osid.learning.ActivityForm.get_assets_metadata_template
        metadata = dict(self._mdata['assessments'])
        metadata.update({'existing_assessments_values': self._my_map['assessmentIds']})
        return Metadata(**metadata)
189949
def get_minimal_id(self):
        

        if not self.__response:
            raise TwitterSearchException(1013)

        return min(
            self.__response['content']['statuses'] if self.__order_is_search
            else self.__response['content'],
            key=lambda i: i['id']
            )['id'] - 1