Return the individual sizes of the given objects
           (with modified options, see method  **set**).
14342
def asizesof(self, *objs, **opts):
        '''
        '''
        if opts:
            self.set(**opts)
        _, t = self._sizes(objs, None)
        return t
286141
def itemsize_bits(self):
        """"""
        if self.dtype is not None:
            return self.dtype.itemsize * 8
        else:
            return sum(x[1] for x in self.format)
243714
def sizes
      @attrs.fetch(:sizes, []).each_with_object({}) do |(key, value), object|
        object[key] = Size.new(value)
      end
    end
1356133
def _get_instance_dimensions(self, ds):
        '''
        
        '''
        ret_val = []
        for variable in ds.get_variables_by_attributes(cf_role=lambda x: isinstance(x, basestring)):
            if variable.ndim > 0:
                ret_val.append(variable.dimensions[0])
        return ret_val
578579
@SuppressWarnings("PMD.UnusedLocalVariable")
  public static <T> int size(Iterable<T> iter) {
    if (iter instanceof ArrayTagSet) {
      return ((ArrayTagSet) iter).size();
    } else if (iter instanceof Collection<?>) {
      return ((Collection<?>) iter).size();
    } else {
      int size = 0;
      for (T v : iter) {
        ++size;
      }
      return size;
    }
  }
712082
def get_size(self):
        """"""
        attr = self._get_console_info()
        cols = attr['window']['right'] - attr['window']['left'] + 1
        lines = attr['window']['bottom'] - attr['window']['top'] + 1
        return cols, lines
340839
def size(self):
        

        if self.id.endswith("/"):
            return sum(Queue(q).size() for q in self.get_known_subqueues())

        # ZSET
        if self.is_sorted:
            return context.connections.redis.zcard(self.redis_key)
        # SET
        elif self.is_set:
            return context.connections.redis.scard(self.redis_key)
        # LIST
        else:
            return context.connections.redis.llen(self.redis_key)
191362
def get_size(cls):
        
        return sum([getattr(cls, name).length
                    for name in cls.get_fields_names()])
409220
def size(self):
        """"""
        initial_count = self.count()
        count_with_skip = max(0, initial_count - self._skip)
        size = min(count_with_skip, self._limit)
        return size
583433
def size
      SIZE_DETERMINERS.each do |predicate, get_size|
        next unless predicate.call
        size = get_size.call
        return size unless size == [0, 0]
      end
    rescue Exception => ex
      raise ex if @unsafe
      Terminal.default_size
    end
563651
def get_size(self, value=None):
        
        if isinstance(value, type(self)):
            return value.get_size()

        return 2 + self.length
678946
def getsizeof(o, ids=None):
    '''
    
    '''
    ids = ids or set()
    if id(o) in ids:
        return 0

    nbytes = sys.getsizeof(o)
    ids.add(id(o))

    if isinstance(o, Mapping):
        return nbytes + sum(getsizeof(k, ids) + getsizeof(v, ids)
                            for k, v in o.items())
    elif isinstance(o, Container):
        return nbytes + sum(getsizeof(x, ids) for x in o)

    return nbytes
1293243
def photo_sizes
      @attrs.fetch(:photo_sizes, []).each_with_object({}) do |(key, value), object|
        object[key] = Size.new(value)
      end
    end
529023
def sizes(self):
        
        if self.attributes.get('sizes'):
            for settings in self.attributes.get('sizes'):
                for pair in itertools.product(
                    shlex.split(settings['block']), shlex.split(settings['transfer'])
                ):
                    yield pair
        else:
            for pair in itertools.product(self.block_size, self.transfer_size):
                yield pair
976948
def fetch_size fsz, &block
    obj = self.dup
    obj.instance_variable_set :@fetch_size, fsz
    ret obj, &block
  end
633932
def Size(self):
        
        return s.uint8 + s.uint8 + GetVarSize(self.Attributes) + GetVarSize(self.inputs) + GetVarSize(self.outputs) + GetVarSize(self.Scripts)
687595
def size(self, pairs_only=False):
        '''
        
        '''
        if pairs_only:
            return len(self.just_pairs)
        else:
            return len(self.heavies)