func NewWriterLevel(w io.Writer, level int) (*Writer, error) {
	return NewWriterLevelDict(w, level, nil)
}

// NewWriterLevelDict is like NewWriterLevel but specifies a dictionary to
// compress with.
//
// The dictionary may be nil. If not, its contents should not be modified until
// the Writer is closed.
func NewWriterLevelDict(w io.Writer, level int, dict []byte) (*Writer, error) {

func NewReader(r io.Reader) (io.ReadCloser, error) {
	return NewReaderDict(r, nil)
}

// NewReaderDict is like [NewReader] but uses a preset dictionary.
// NewReaderDict ignores the dictionary if the compressed data does not refer to it.
// If the compressed data refers to a different dictionary, NewReaderDict returns [ErrDictionary].
//
// The ReadCloser returned by NewReaderDict also implements [Resetter].

  if (identifier == "trackable_dict_wrapper") {
    tf::libtf::Dictionary user_dict;
    // TODO(b/191267013): Populate with values.
    return user_dict;
  }
  if (identifier == "signature_map") {
    tf::libtf::Dictionary signature_map;
    // TODO(b/191267013): Populate with values.
    return signature_map;
  }
  if (identifier == "_generic_user_object") {
    tf::libtf::Dictionary user_object;
    // TODO(b/191267013): Populate with values.

  if (config == nullptr) {
    op.emitOpError() << "does not have dictionary attribute '"
                     << kTfBackendConfigAttrName << "'";
    return failure();
  }

  auto f = config.get(kCalledFuncAttrName);
  if (f == nullptr) {
    op.emitOpError() << "does not have attribute '" << kCalledFuncAttrName
                     << "' in its dictionary attribute '"
                     << kTfBackendConfigAttrName << "'";

  }

  return mlir::success();
}

// Get devices from a dictionary attribute.
mlir::LogicalResult GetDevicesFromOp(mlir::Operation* op,
                                     mlir::DictionaryAttr dict_attr,
                                     mlir::TF::RuntimeDevices* devices) {
  DeviceNameUtils::ParsedName device;

  // Parse device names and metadata from dictionary attribute.
  for (auto& kv : dict_attr) {

```

## Metadata for tags

You can also add additional metadata for the different tags used to group your path operations with the parameter `openapi_tags`.

It takes a list containing one dictionary for each tag.

Each dictionary can contain:

* `name` (**required**): a `str` with the same tag name you use in the `tags` parameter in your *path operations* and `APIRouter`s.

        String[] values = CSVUtil.parse(rule);
        if (dup.add(values[0]) == false) {
            throw new IllegalArgumentException("Found duplicate term [" + values[0] + "] in user dictionary.");
        }
        return rule;
    }

    public static UserDictionary getUserDictionary(Environment env, Settings settings) {

		},
		nil,
		nil,
	},
	{
		"dictionary",
		"Hello, World!\n",
		[]byte{
			0x78, 0xbb, 0x1c, 0x32, 0x04, 0x27, 0xf3, 0x00,
			0xb1, 0x75, 0x20, 0x1c, 0x45, 0x2e, 0x00, 0x24,
			0x12, 0x04, 0x74,
		},
		[]byte{
			0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x0a,
		},
		nil,
	},
	{
		"wrong dictionary",
		"",
		[]byte{

// run

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test cases where a main dictionary is needed inside a generic function/method, because
// we are calling a method on a fully-instantiated type or a fully-instantiated function.
// (probably not common situations, of course)

package main

import (
	"fmt"
)

namespace TF {

// Returns whether the custom call op represents a TF function call.
bool IsTfFuncCustomCall(stablehlo::CustomCallOp op);

// Returns the `called_func` symbol ref attribute in the `tf.backend_config`
// dictionary attribute.
//
// If the op does not represent a TF function call, returns nullptr.
// Otherwise, if the op does not have `caller_name`, returns failure.
FailureOr<SymbolRefAttr> GetTfFuncCustomCallFuncName(