paramMap.put(Param.Client.PROXY_HOST, proxyHost);
            paramMap.put(Param.Client.PROXY_PORT, proxyPort);
            final String proxyUsername = fessConfig.getHttpProxyUsername();
            final String proxyPassword = fessConfig.getHttpProxyPassword();
            if (proxyUsername != null && proxyPassword != null) {

        }
        elementsAll.put(fieldName, newArray);
        elementsText.put(fieldName, newArray);
    }

    protected void addFileParameter(final DiskFileItem item) {
        final String fieldName = item.getFieldName();
        final MultipartFormFile formFile = newActionMultipartFormFile(item);
        elementsAll.put(fieldName, formFile);
        elementsFile.put(fieldName, formFile);
    }

While building an API, the "path" is the main way to separate "concerns" and "resources".

#### Operation

"Operation" here refers to one of the HTTP "methods".

One of:

* `POST`
* `GET`
* `PUT`
* `DELETE`

...and the more exotic ones:

* `OPTIONS`
* `HEAD`
* `PATCH`
* `TRACE`

In the HTTP protocol, you can communicate to each path using one (or more) of these "methods".

---

#### List

For example, let's define a variable to be a `list` of `str`.

//// tab | Python 3.9+

Declare the variable, with the same colon (`:`) syntax.

As the type, put `list`.

As the list is a type that contains some internal types, you put them in square brackets:

```Python hl_lines="1"
{!> ../../docs_src/python_types/tutorial006_py39.py!}
```

////

//// tab | Python 3.8+

        addFieldRule(name, xpath);
        fieldPrunedRuleMap.put(name, isPruned);
    }

    public void setConvertUrlMap(final Map<String, String> convertUrlMap) {
        this.convertUrlMap.putAll(convertUrlMap);
    }

    public void addConvertUrl(final String regex, final String replacement) {
        convertUrlMap.put(regex, replacement);
    }

```

////

### Technical details about the JWT "subject" `sub`

The JWT specification says that there's a key `sub`, with the subject of the token.

It's optional to use it, but that's where you would put the user's identification, so we are using it here.

JWT might be used for other things apart from identifying a user and allowing them to perform operations directly on your API.

            protected PathMappingHelper getPathMappingHelper() {
                return new PathMappingHelper();
            }
        };
        fessXpathTransformer.init();
        fessXpathTransformer.convertUrlMap.put("feed:", "http:");

        List<RequestData> urlList = new ArrayList<>();

        urlList = fessXpathTransformer.convertChildUrlList(urlList);
        assertEquals(0, urlList.size());

        urlList.clear();

			}
		}
	}
	return ObjectOptions{
		Versioned:        versioned,
		VersionSuspended: versionSuspended,
		VersionID:        vid,
	}, nil
}

// set ObjectOptions for PUT call to restore temporary copy of transitioned data
func putRestoreOpts(bucket, object string, rreq *RestoreObjectRequest, objInfo ObjectInfo) (putOpts ObjectOptions) {
	meta := make(map[string]string)

	// Normal execution.
	for {
		r1, _, err := r.ReadRune()
		if err != nil {
			if err != io.EOF {
				t.Error("unexpected error on ReadRune:", err)
			}
			break
		}
		got += string(r1)
		// Put it back and read it again.
		if err = r.UnreadRune(); err != nil {
			t.Fatal("unexpected error on UnreadRune:", err)
		}
		r2, _, err := r.ReadRune()
		if err != nil {

	var bufp *[]byte
	switch {
	case fileSize <= xioutil.SmallBlock:
		bufp = xioutil.ODirectPoolSmall.Get().(*[]byte)
		defer xioutil.ODirectPoolSmall.Put(bufp)
	default:
		bufp = xioutil.ODirectPoolLarge.Get().(*[]byte)
		defer xioutil.ODirectPoolLarge.Put(bufp)
	}

	var written int64
	if odirectEnabled {
		written, err = xioutil.CopyAligned(diskHealthWriter(ctx, w), r, *bufp, fileSize, w)
	} else {