/// tip

Prefer to use the `Annotated` version if possible.

///

```Python
commons: CommonQueryParams = Depends(CommonQueryParams)
```

////

The last `CommonQueryParams`, in:

```Python
... Depends(CommonQueryParams)
```

...is what **FastAPI** will actually use to know what is the dependency.

	isListingRequest := r.Form.Has("list")

	var buckets []string
	if strings.HasPrefix(pathComponents, "/bucket/") {
		// bucket specific metrics, extract the bucket name from the path.
		// it's the last part of the path. e.g. /bucket/api/<bucket-name>
		bucketIdx := strings.LastIndex(pathComponents, "/")
		buckets = append(buckets, pathComponents[bucketIdx+1:])
		// remove bucket from pathComponents as it is dyanamic and

      }
      if (!sink.finished) {
        // We have 0 or more frames of data, and 0 or more frames of trailers. We need to send at
        // least one frame with the END_STREAM flag set. That must be the last frame, and the
        // trailers must be sent after all of the data.
        val hasData = sendBuffer.size > 0L
        val hasTrailers = trailers != null
        when {
          hasTrailers -> {

            SMBUtil.writeInt8(creationTime, buffer, bufferIndex + 8);
            // Last Access Time (8 bytes)
            long lastAccessTime = creationTime + 1000000L;
            SMBUtil.writeInt8(lastAccessTime, buffer, bufferIndex + 16);
            // Last Write Time (8 bytes)
            long lastWriteTime = creationTime + 2000000L;

  private static boolean isTimed(Method method) {
    return isLongTimeUnitBased(method) || isDurationBased(method);
  }

  /** Determines whether the given method takes a time and unit as its last two parameters. */
  private static boolean isLongTimeUnitBased(Method method) {
    Class<?>[] parameterTypes = method.getParameterTypes();
    return parameterTypes.length >= 2

        long lastAccess = file.lastAccess();

        assertTrue(createTime > 0, "Create time should be set");
        assertTrue(lastModified > 0, "Last modified time should be set");
        assertTrue(lastAccess >= 0, "Last access time should be non-negative");

        // Test setting attributes
        file.setReadOnly();
        assertFalse(file.canWrite(), "Should not be writable when read-only");

    /** The key of the message: by Last Modified (asc) */
    public static final String LABELS_search_result_sort_last_modified_asc = "{labels.search_result_sort_last_modified_asc}";

    /** The key of the message: by Last Modified (desc) */

    TreeMultimap<@Nullable String, @Nullable Integer> multimap = createPopulate();
    SortedSet<@Nullable String> keySet = multimap.keySet();

    assertEquals(null, keySet.first());
    assertEquals("google", keySet.last());
    assertEquals(StringLength.COMPARATOR, keySet.comparator());
    assertEquals(Sets.<@Nullable String>newHashSet(null, "tree"), keySet.headSet("yahoo"));
    assertEquals(newHashSet("google"), keySet.tailSet("yahoo"));

- Temporary credentials are short-term, as the name implies. They can be configured to last for anywhere from a few minutes to several hours. After the credentials expire, MinIO no longer recognizes them or allows any kind of access from API requests made with them.

	// Compute endEncOffset with one additional DARE package (so
	// we read the package containing the last desired byte).
	endEncOffset := encCumulativeSum + (endPkgNum+1)*sseDAREEncPackageBlockSize
	// Check if the DARE package containing the end offset is a
	// full sized package (as the last package in the part may be
	// smaller)
	lastPartSize, _ := sio.EncryptedSize(uint64(sizes[partEnd]))