Return the actual list from the stored start/stop/step.
324597
def _render(self):
        """"""
        return list(self._parent)[self._start:self._stop:self._step]
1201217
def all(self) -> List[Any]:
        
        values = []
        for name, value in self._entrypoints.items():
            if isinstance(value, EntryPoint):
                value = self._entrypoints[name] = value.load()

            values.append(value)

        return values
1258749
def get_prev_step(self, step=None):
        
        if step is None:
            step = self.steps.current
        form_list = self.get_form_list()
        keys = list(form_list.keys())
        key = keys.index(step) - 1
        if key >= 0:
            for prev_step in keys[key::-1]:
                if self.is_step_visible(prev_step):
                    return prev_step
        return None
39884
def _get_list(self, key, operation, create=False):
        
        return self._get_by_type(key, operation, create, b'list', [])
1091905
def get_step_table_names(steps):
    
    table_names = set()
    for s in steps:
        table_names |= get_step(s)._tables_used()
    return list(table_names)
1238733
def find(self, chrom, start, end):
        """"""

        tree = self._trees.get( chrom, None )
        if tree:
            return tree.find( start, end )
        #return always a list
        return []
263315
def getExperimentList():
  
  contents = sio.loadmat("./data/DataFolderList.mat",
                         variable_names=['DataFolderList'],
                         struct_as_record=False,
                         squeeze_me=True)

  return contents['DataFolderList']
1157980
def start_stop(name, start, stop, data=''):
        
        return [
            Command('start_%s' % name, start, data),
            Command('stop_%s' % name, stop, data),
        ]
1370909
def read_bplist(data, start, length):
    """"""
    # TODO: pylint doesn't find FMT_BINARY, why?
    # pylint: disable=no-member
    return plistlib.loads(data[start:start+length],
                          fmt=plistlib.FMT_BINARY)
694079
def list(self):
        
        before, after = self.filename_template.split('%s', 1)
        filename_re = re.compile(r'%s(.{5,})%s$' % (re.escape(before),
                                                    re.escape(after)))
        result = []
        for filename in os.listdir(self.path):
            #: this is a session that is still being saved.
            if filename.endswith(_fs_transaction_suffix):
                continue
            match = filename_re.match(filename)
            if match is not None:
                result.append(match.group(1))
        return result
1398
def data(self):
        """"""
        import warnings
        warnings.warn(
            '`data` attribute is deprecated and will be removed in a future release, '
            'use %s as an iterable instead' % (PaginatedResponse,),
            category=DeprecationWarning,
            stacklevel=2  # log wherever '.data' is referenced, rather than this line
        )
        return list(self)
406045
function(start, stop, step) {
        if (arguments.length === 1) return funcifyr.range(1, start, 1);
        if (arguments.length === 2) return funcifyr.range(start, stop, 1);

        var result = [];

        for (var i = start; i <= stop; i += step) {
          result.push(i);
        }

        return result;
      }
522536
def _pass_list(self) -> List[Dict[str, Any]]:
        """"""
        stops: List[Dict[str, Any]] = []
        for stop in self.journey.PassList.BasicStop:
            index = stop.get("index")
            station = stop.Location.Station.HafasName.Text.text
            station_id = stop.Location.Station.ExternalId.text
            stops.append({"index": index, "stationId": station_id, "station": station})
        return stops
279171
def _read_stepfiles_list(path_prefix, path_suffix=".index", min_steps=0):
  """"""
  stepfiles = []
  for filename in _try_twice_tf_glob(path_prefix + "*-[0-9]*" + path_suffix):
    basename = filename[:-len(path_suffix)] if path_suffix else filename
    try:
      steps = int(basename.rsplit("-")[-1])
    except ValueError:  # The -[0-9]* part is not an integer.
      continue
    if steps < min_steps:
      continue
    if not os.path.exists(filename):
      tf.logging.info(filename + " was deleted, so skipping it")
      continue
    stepfiles.append(StepFile(basename, os.path.getmtime(filename),
                              os.path.getctime(filename), steps))
  return sorted(stepfiles, key=lambda x: -x.steps)
951793
def starts(self, layer):
        """"""
        starts = []
        for data in self[layer]:
            starts.append(data[START])
        return starts
772695
def list(self, limit=None, marker=None, end_marker=None, prefix=None):
        
        return self._manager.list(limit=limit, marker=marker,
                end_marker=end_marker, prefix=prefix)
480694
def keys(self, start=None, stop=None):
        """"""
        return (item[0] for item in self.items(start, stop))