case "ts":
			var zb0002 uint32
			zb0002, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "Tiers")
				return
			}
			if z.Tiers == nil {
				z.Tiers = make(map[string]tierStats, zb0002)
			} else if len(z.Tiers) > 0 {
				for key := range z.Tiers {
					delete(z.Tiers, key)
				}
			}
			for zb0002 > 0 {
				zb0002--
				var za0001 string
				var za0002 tierStats

	"time"

	"golang.org/x/oauth2"

	"github.com/minio/minio-go/v7"
	"github.com/minio/minio-go/v7/pkg/credentials"
)

// Returns a base64 encoded random 32 byte string.
func randomState() string {
	b := make([]byte, 32)
	rand.Read(b)
	return base64.RawURLEncoding.EncodeToString(b)
}

var (
	stsEndpoint    string
	configEndpoint string
	clientID       string
	clientSec      string
	clientScopes   string

## Using `TestClient` { #using-testclient }

/// info

To use `TestClient`, first install <a href="https://www.python-httpx.org" class="external-link" target="_blank">`httpx`</a>.

Make sure you create a [virtual environment](../virtual-environments.md){.internal-link target=_blank}, activate it, and then install it, for example:

```console
$ pip install httpx
```

///

Import `TestClient`.

		case "bkts":
			var zb0002 uint32
			zb0002, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "BucketStatuses")
				return
			}
			if z.BucketStatuses == nil {
				z.BucketStatuses = make(map[string]ResyncStatusType, zb0002)
			} else if len(z.BucketStatuses) > 0 {
				for key := range z.BucketStatuses {
					delete(z.BucketStatuses, key)
				}
			}
			for zb0002 > 0 {
				zb0002--

			argumentValue = tag
			valid = false
			return
		}
	}

	return
}

func parseObjectAttributes(h http.Header) (attributes map[string]struct{}) {
	attributes = make(map[string]struct{})
	for _, headerVal := range h.Values(xhttp.AmzObjectAttributes) {
		for v := range strings.SplitSeq(strings.TrimSpace(headerVal), ",") {
			if v != "" {
				attributes[v] = struct{}{}
			}
		}

// By default at least 128 entries in single getdents call (1MiB buffer)
var (
	direntPool = bpool.Pool[*[]byte]{
		New: func() *[]byte {
			buf := make([]byte, blockSize*128)
			return &buf
		},
	}

	direntNamePool = bpool.Pool[*[]byte]{
		New: func() *[]byte {
			buf := make([]byte, blockSize)
			return &buf
		},
	}
)

// unexpectedFileMode is a sentinel (and bogus) os.FileMode

// newNSLock - return a new name space lock map.
func newNSLock(isDistErasure bool) *nsLockMap {
	nsMutex := nsLockMap{
		isDistErasure: isDistErasure,
	}
	if isDistErasure {
		return &nsMutex
	}
	nsMutex.lockMap = make(map[string]*nsLock)
	return &nsMutex
}

// nsLock - provides primitives for locking critical namespace regions.
type nsLock struct {
	ref int32
	*lsync.LRWMutex
}

 * </ul>
 *
 * To force selection of our fallback strategies we load {@link AggregateFutureState} (and all of
 * {@code com.google.common.util.concurrent}) in degenerate class loaders which make certain
 * platform classes unavailable. Then we construct a test suite so we can run the normal FuturesTest
 * test methods in these degenerate classloaders.
 */

@NullUnmarked

func (dui DataUsageInfo) tierStats() []madmin.TierInfo {
	if dui.TierStats == nil {
		return nil
	}

	if globalTierConfigMgr.Empty() {
		return nil
	}

	ts := make(map[string]madmin.TierStats)
	dui.TierStats.populateStats(ts)

	infos := make([]madmin.TierInfo, 0, len(ts))
	for tier, stats := range ts {
		infos = append(infos, madmin.TierInfo{
			Name:  tier,
			Type:  globalTierConfigMgr.TierType(tier),

When you declare a default value for non-path parameters (for now, we have only seen query parameters), then it is not required.

If you don't want to add a specific value but just make it optional, set the default as `None`.

But when you want to make a query parameter required, you can just not declare any default value:

{* ../../docs_src/query_params/tutorial005.py hl[6:7] *}