// from a placeholder node "arg_tensor_enqueue_<tensor_id>".
//
// `tensor` is still owned by the caller. This call will be blocked if the queue
// has reached its capacity, and will be unblocked when the queued tensors again
// drop below the capacity due to dequeuing.
//
// Tensors are dequeued via the corresponding TF dequeue op.
// TODO(hongm): Add support for `timeout_ms`.

  - New objects inherit the retention settings of the bucket object lock configuration automatically
  - Retention headers can be optionally set while uploading objects
  - Once objects are uploaded PutObjectRetention API can be called to change retention settings
- *MINIO_NTP_SERVER* environment variable can be set to remote NTP server endpoint if system time is not desired for setting retention dates.

## Explore Further

# Dependencies with yield { #dependencies-with-yield }

FastAPI supports dependencies that do some <abbr title='sometimes also called "exit code", "cleanup code", "teardown code", "closing code", "context manager exit code", etc.'>extra steps after finishing</abbr>.

To do this, use `yield` instead of `return`, and write the extra steps (code) after.

/// tip

Make sure to use `yield` one single time per dependency.

///

/// note | Technical Details

			i, err = d.objectOrdered()
		} else {
			i, err = d.object()
		}
		return i, Object, err
	default:
		return nil, Unknown, d.mkError(ErrSyntax, "looking for beginning of value")
	}
}

// string called by `any` or `object`(for map keys) after reading `"`
func (d *Decoder) string() (string, error) {
	d.scratch.reset()
	c := d.next()

scan:
	for {
		switch {
		case c == '"':

                .desc("Defines the color mode of the output. Supported are 'auto', 'always', 'never'.")
                .build());
        options.addOption(Option.builder(CACHE_ARTIFACT_NOT_FOUND)
                .longOpt("cache-artifact-not-found")
                .hasArg()
                .desc(
                        "Defines caching behaviour for 'not found' artifacts. Supported values are 'true' (default), 'false'.")
                .build());

```Python hl_lines="1"
async def get_burgers(number: int):
    # Mache hier etwas Asynchrones, um die Burger zu erstellen
    return burgers
```

... statt mit `def`:

```Python hl_lines="2"
# Dies ist nicht asynchron
def get_sequential_burgers(number: int):
    # Mache hier etwas Sequentielles, um die Burger zu erstellen
    return burgers
```

			gotCall <- struct{}{}
			select {
			case <-ctx.Done():
				gotCall <- struct{}{}
			case <-cleanReqs:
				panic("should not be called")
			}
			return nil
		},
		OutCapacity: 1,
		InCapacity:  1,
	}
	errFatal(remote.RegisterSingleHandler(handlerTest, h1))
	errFatal(remote.RegisterStreamingHandler(handlerTest2, h2))

const (
	DefaultBitrotAlgorithm = HighwayHash256S
)

// ObjectPartInfo Info of each part kept in the multipart metadata
// file after CompleteMultipartUpload() is called.
type ObjectPartInfo struct {
	ETag       string            `json:"etag,omitempty" msg:"e"`
	Number     int               `json:"number" msg:"n"`

            throw new RuntimeException(message);
        }
        if (candidates.size() != 1) {
            String message = String.format("Found multiple methods called '%s' in class '%s'. Candidates: %s",
                    method, className, CollectionUtils.join(", ", candidates));
            message += "\nThis problem may happen when some apilink from docbook template xmls is incorrect. Example:"

	}

	_, err := trw.Write([]byte("hello"))
	if err != nil {
		t.Fatalf("Write unexpectedly failed: %v", err)
	}

	// Check that WriteHeader and Write were called on the underlying response writer
	resp := rw.Result()
	if resp.StatusCode != 123 {
		t.Fatalf("unexpected status: %v", resp.StatusCode)
	}
	body, err := io.ReadAll(resp.Body)
	if err != nil {