:param obj_name: requested object name
        :returns: all statistics values for the requested object.
763609
def get_object_stats(self, obj_name):
        

        return dict(zip(self.captions, self.statistics[obj_name]))
751596
def get_object(objref, data=None, return_fields=None, max_results=None,
               ensure_none_or_one_result=False, **api_opts):
    '''
    
    '''
    if not data:
        data = {}
    infoblox = _get_infoblox(**api_opts)
    return infoblox.get_object(objref, data, return_fields,
                               max_results, ensure_none_or_one_result)
164422
def _make_object_dict(self, obj):
        
        data = {}
        for attr in dir(obj):
            if attr[0] is not '_' and attr is not 'status':
                datum = getattr(obj, attr)
                if not isinstance(datum, types.MethodType):
                    data.update(self._handle_object(attr,datum))
        return data
102843
private static Statistics getStatistics(String category, String name)
   {
      StatisticsContext context = getContext(category);
      if (context == null)
      {
         return null;
      }
      // Format the name
      name = formatName(name);
      if (name == null)
      {
         return null;
      }
      Statistics statistics;
      if (GLOBAL_STATISTICS_NAME.equalsIgnoreCase(name))
      {
         statistics = context.global;
      }
      else
      {
         statistics = context.allStatistics.get(name);
      }
      return statistics;
   }
321582
def stats(self):
        
        response = self.requester.get(
            '/{endpoint}/{id}/stats',
            endpoint=self.endpoint, id=self.id
        )
        return response.json()
935843
def get_hit_count_from_obj_variable(context, obj_variable, tag_name):
    
    error_to_raise = template.TemplateSyntaxError(
        "'%(a)s' requires a valid individual model variable "
        "in the form of '%(a)s for [model_obj]'.\n"
        "Got: %(b)s" % {'a': tag_name, 'b': obj_variable}
    )

    try:
        obj = obj_variable.resolve(context)
    except template.VariableDoesNotExist:
        raise error_to_raise

    try:
        ctype = ContentType.objects.get_for_model(obj)
    except AttributeError:
        raise error_to_raise

    hit_count, created = HitCount.objects.get_or_create(
        content_type=ctype, object_pk=obj.pk)

    return hit_count
1328227
def _safe_object_name(self, object_name):
        
        extension = get_file_extension(object_name)
        file_name = os.path.splitext(object_name)[0]
        while object_name in self:
            nuid = uuid.uuid4().hex
            object_name = "%s__%s.%s" % (file_name, nuid, extension)
        return object_name
409344
def all_stats(klass, account, ids, metric_groups, **kwargs):
        
        params = klass._standard_params(ids, metric_groups, **kwargs)

        resource = klass.RESOURCE_SYNC.format(account_id=account.id)
        response = Request(account.client, 'get', resource, params=params).perform()
        return response.body['data']
1261573
def cls_get_by_name(cls, name):
    
    try:
        val = getattr(cls, name)
    except AttributeError:
        for attr in (a for a in dir(cls) if not a.startswith('_')):
            try:
                val = getattr(cls, attr)
            except AttributeError:
                # Is known to happen.
                continue
            valname = getattr(val, 'name', None)
            if valname == name:
                return val
        else:
            raise ValueError('No {} with that name: {}'.format(
                cls.__name__,
                name,
            ))
    else:
        return val
624352
def getMethodByName(obj, name):

    
    try:#to get a method by asking the service
        obj = obj._getMethodByName(name)
    except:
        #assumed a childObject is ment 
        #split the name from objName.childObjName... -> [objName, childObjName, ...]
        #and get all objects up to the last in list with name checking from the service object
        names = name.split(".")
        for name in names:
            if nameAllowed(name):
                obj = getattr(obj, name)
            else:
                raise MethodNameNotAllowed()
        
    return obj
1266287
def get_dict(self, obj, state=None, base_name='View'):
        
        return self.get_dict_for_class(class_name=obj.__class__,
                                       state=obj.state,
                                       base_name=base_name)
728415
def get_rank_value(cls, name):
    
    if name in cls._RANK_NAMES.values():
      return getattr(cls, name, None)
    return None
1052144
def GetStat(self):
    
    if self._stat_object is None:
      self._stat_object = self._GetStat()
    return self._stat_object
883039
def pickle_to_param(obj, name):
	
	return from_pyvalue(u"pickle:%s" % name, unicode(pickle.dumps(obj)))
1101002
def get_object_data(obj, fields, safe):
    

    temp_dict = dict()
    for field in fields:

        try:
            attribute = getattr(obj, str(field))
            if isinstance(attribute, list) and all([isinstance(item, models.Model) for item in attribute]):
                temp_dict[field] = []
                for item in attribute:
                    temp_dict[field].append(get_object_data(item, get_fields(item), safe))  # Recur
            elif isinstance(attribute, models.Model):
                attribute_fields = get_fields(attribute)
                object_data = get_object_data(attribute, attribute_fields, safe)  # Recur
                temp_dict[field] = object_data
            else:
                if not safe:
                    if isinstance(attribute, basestring):
                        attribute = cgi.escape(attribute)
                temp_dict[field] = attribute

        except Exception as e:
            logger.info("Unable to get attribute.")
            logger.error(e)
            continue

    return temp_dict
1101544
def model_stats(self):
        
        stats = self.model.default_stats
        return blob_data_to_dict(stats, self._sampler.blobs)
444557
def get_stats(self, obj, stat_name):
        
        return [int(v) for v in self.get_attribute(obj, stat_name).split()]