}
                }

                final int max = Math.min(dc_list.length, LOOKUP_RESP_LIMIT);
                for (int j = 0; j < max; j++) {
                    final int i = dc_list_counter++ % max;
                    if (dc_list[i] != null) {
                        try {
                            return interrogate(dc_list[i]);
                        } catch (final SmbException se) {

                if (this.dcList[i] != null) {
                    try {
                        return interrogate(getTransportContext(), this.dcList[i]);
                    } catch (final SmbException se) {
                        log.warn("Failed validate DC: " + this.dcList[i], se);
                    }
                    this.dcList[i] = null;
                }
            }

            synchronized (docList) {
                docList.add(ingest(paramMap, dataMap));
                final long contentSize = indexingHelper.calculateDocumentSize(dataMap);
                docList.addContentSize(contentSize);
                final long processingTime = systemHelper.getCurrentTimeAsLong() - startTime;
                docList.addProcessingTime(processingTime);

                                MemoryUtil.byteCountToDisplaySize(contentSize), processingTime, docList.size(), docList.getContentSize());
                    }

                    if (docList.getContentSize() >= maxDocumentRequestSize) {
                        indexingHelper.sendDocuments(searchEngineClient, docList);
                    }
                    documentSize++;
                    if (logger.isDebugEnabled()) {

* Pass the internal type(s) as "type parameters" using square brackets: `[` and `]`

In Python 3.9 it would be:

```Python
my_list: list[str]
```

In versions of Python before 3.9, it would be:

```Python
from typing import List

my_list: List[str]
```

That's all standard Python syntax for type declarations.

Use that same standard syntax for model attributes with internal types.

        }
    }

    private static class TestIndexingHelper extends IndexingHelper {
        @Override
        public void sendDocuments(SearchEngineClient client, DocList docList) {
            docList.clear();
        }

        @Override
        public long calculateDocumentSize(Map<String, Object> map) {
            return 100L;
        }
    }

	for i, testCase := range testCases {
		var dirList []string
		dirList, err = xlStorage.ListDir(t.Context(), "", testCase.srcVol, testCase.srcPath, -1)
		if err != testCase.expectedErr {
			t.Errorf("TestXLStorage case %d: Expected: \"%s\", got: \"%s\"", i+1, testCase.expectedErr, err)
		}
		if err == nil {
			for _, expected := range testCase.expectedListDir {
				if !strings.Contains(strings.Join(dirList, ","), expected) {

     *
     * @param index   the target index
     * @param docList list of documents to add
     * @param options callback for customizing index request options
     * @return the bulk response
     */
    public BulkResponse addAll(final String index, final List<Map<String, Object>> docList,
            final BiConsumer<Map<String, Object>, IndexRequestBuilder> options) {