code: def positional(self, *dims):
      from . import Dim, DimensionBindError, Tensor
  
      ptensor, levels = self._tensor, llist(self._levels)
      flat_dims = llist()
      view = []
      needs_view = False
      ndim = self.ndim
      for d in dims:
          if isinstance(d, DimList):
              flat_dims.extend(d)
              view.extend(e.size for e in d)
          elif isinstance(d, Dim):
              flat_dims.append(d)
              view.append(d.size)
          elif isinstance(d, int):
              d = _wrap_dim(d, ndim, False)
              flat_dims.append(d)
              view.append(ptensor.size(d))
          else:
              flat_dims.extend(d)
              view.append(prod(e.size for e in d))
              needs_view = True
  
      permute = list(range(len(levels)))
      nflat = len(flat_dims)
      for i, d in enumerate(flat_dims):
          try:
              idx = levels.index(d)
          except ValueError as e:
              raise DimensionBindError(
                  f"tensor of dimensions {self.dims} does not contain dim {d}"
              ) from e
          p = permute[idx]
          del levels[idx]
          del permute[idx]
          levels.insert(i, 0)
          permute.insert(i, p)
      ptensor = ptensor.permute(*permute)
      seen = 0
      for i in range(len(levels) - 1, -1, -1):
          if isinstance(levels[i], int):
              seen += 1
              levels[i] = -seen
      result = Tensor.from_positional(ptensor, levels, self._has_device)
      if needs_view:
          result = result.reshape(
              *view, *result.size()[len(flat_dims) :]
          )
      return result
  
imports: import torch
  from functorch._C import dim
  from .None import op_properties
  from .batch_tensor import _enable_layers
  from .tree_map import tree_flatten, tree_map
  import operator
  from functools import reduce
label_desc: Use image node_id 10 for calling a global function with example usage: positional() and returns: result