The method is getting information about dimension with items
350429
def get_dimension(self, dataset, dimension):
        """"""

        path = '/api/1.0/meta/dataset/{}/dimension/{}'
        return self._api_get(definition.Dimension, path.format(dataset, dimension))
1038033
def find_dimension_by_name(self, dim_name):
        """"""

        for dim in self.dimensions:
            if is_equal_strings_ignore_case(dim.name, dim_name):
                return dim
        return None
825528
def _evaluate_dimension_fields(self) -> bool:
        
        for _, item in self._dimension_fields.items():
            item.run_evaluate()
            if item.eval_error:
                return False
        return True
124092
def dimensions
      rows = []
      cols = []
      @win.getmaxyx(rows, cols)
      rows = rows.first
      cols = cols.first
      [rows, cols]
    end
521192
def _raw_dimensions(self):
        """"""
        return tuple(
            _RawDimension(dimension_dict, self._dimension_dicts)
            for dimension_dict in self._dimension_dicts
        )
993318
public int dimension()
    {
        if (storage == null || storage.isEmpty())
        {
            return 0;
        }
        return storage.values().iterator().next().size();
    }
686477
def static_dimensions(self):
        
        dimensions = []
        for dim in self.kdims:
            if len(set(self.dimension_values(dim.name))) == 1:
                dimensions.append(dim)
        return dimensions
61321
function selectDimensionsAndMaterials() {
  let reverbLength = document.getElementById('reverbLengthSelect').value;
  switch (reverbLength) {
    case 'none':
    default:
    {
      return {
        dimensions: {
          width: 0,
          height: 0,
          depth: 0,
        },
        materials: {
          left: 'transparent',
          right: 'transparent',
          front: 'transparent',
          back: 'transparent',
          up: 'transparent',
          down: 'transparent',
        },
      };
    }
    break;
    case 'short':
    {
      return {
        dimensions: {
          width: 1.5,
          height: 1.5,
          depth: 1.5,
        },
        materials: {
          left: 'uniform',
          right: 'uniform',
          front: 'uniform',
          back: 'uniform',
          up: 'uniform',
          down: 'uniform',
        },
      };
    }
    break;
    case 'medium':
    {
      return {
        dimensions: {
          width: 6,
          height: 6,
          depth: 6,
        },
        materials: {
          left: 'uniform',
          right: 'uniform',
          front: 'uniform',
          back: 'uniform',
          up: 'uniform',
          down: 'uniform',
        },
      };
    }
    break;
    case 'long':
    {
      return {
        dimensions: {
          width: 24,
          height: 24,
          depth: 24,
        },
        materials: {
          left: 'uniform',
          right: 'uniform',
          front: 'uniform',
          back: 'uniform',
          up: 'uniform',
          down: 'uniform',
        },
      };
    }
    break;
  }
}
510270
def get_list_dimensions(_list):
    
    if isinstance(_list, list) or isinstance(_list, tuple):
        return [len(_list)] + get_list_dimensions(_list[0])
    return []
1176114
def get_dimensions(**kwargs):
    
    dimensions_list = db.DBSession.query(Dimension).options(load_only("id")).all()
    return_list = []
    for dimension in dimensions_list:
        return_list.append(get_dimension(dimension.id))


    return return_list
295296
def unit_string
      use_dimension
      a = []
      a << Utils.num_inspect(@factor) if @factor!=1
      a += @dim.map do |k,d|
        if d==1
          k
        else
          "#{k}^#{d}"
        end
      end
      a.join(" ")
    end
993010
function(dimensions) {
   var simplex = new gamejs.math.noise.Simplex(Math);
   var surfaceData = [];
   for (var i=0;i<dimensions[0];i++) {
      surfaceData[i] = [];
      for (var j=0;j<dimensions[1];j++) {
         var val = simplex.get(i/50, j/50) * 255;
         surfaceData[i][j] = val;
      }
   }
   return surfaceData;
}
788042
def info(self):
        
        if (len(self.values()) > 0):
            info_str = self.__class__.__name__ +\
                       " containing %d items of type %s\n" % (len(self.keys()),
                                                              type(self.values()[0]).__name__)
        else:
            info_str = self.__class__.__name__ + " containing no items\n"
        info_str += ('-' * (len(info_str)-1)) + "\n\n"
        aliases = {v: k for k, v in self._dim_aliases.items()}
        for group in self._dim_groups:
            dimensions = getattr(self, group)
            if dimensions:
                group = aliases[group].split('_')[0]
                info_str += '%s Dimensions: \n' % group.capitalize()
            for d in dimensions:
                dmin, dmax = self.range(d.name)
                if d.value_format:
                    dmin, dmax = d.value_format(dmin), d.value_format(dmax)
                info_str += '\t %s: %s...%s \n' % (d.pprint_label, dmin, dmax)
        print(info_str)
1107751
def get_dimensions(filenames):
    """"""

    dims = []
    for filename in filenames:
        implemented = False
        with open(filename, 'rb') as fp:

            img_types = (PNGFile, GIFFile, JPEGFile)
            for img_type in img_types:
                sig = str(getattr(img_type, 'SIGNATURE')[0])
                magic = fp.read(len(sig))
                fp.seek(0)
                if magic == sig:
                    cls = img_type.__name__.split('.')[-1]
                    img = getattr(img_type, cls)(fp)
                    x, y = img.size
                    dims.append((x, y, img.content_type, filename))
                    implemented = True
                    break
            if not implemented:
                # might want to fail silently, or print error to stdout...
                print('cannot handle file: %s' % filename)
                raise NotImplementedError
    return dims
263066
function(context) {
        var contextObj = {};
        for(var i=0; i<context.length; i++) {
            if(context[i] !== '0') {
                contextObj[this.dimensionsList[i]] = this.numberToValue[context[i]];
            }
        }
        return contextObj;
    }
1004758
def _compare_dimensions_to_fields(self) -> bool:
        
        for name, item in self._dimension_fields.items():
            if item.value != self._nested_items[name].value:
                return False
        return True
489730
def data_item(data):
    
    if isinstance(data, ndict):
        # OK, we have something that looks like {0: ('a', 'b')}
        # or something that is a regular dictionary
        # so try to return 'a' regardless of the length
        for item in data:
            return repr(data[item][0])
    elif isinstance(data, dict):
        for item in data:
            return repr(data[item])
    elif isinstance(data, list):
        return repr(data[0])
    return repr(data)