*            The resource path. Must not be {@literal null} or empty string.
     * @return {@literal true} if the resource exists
     * @see #getResourceNoException(String)
     */
    public static boolean isExist(final String path) {
        assertArgumentNotEmpty("path", path);

        return getResourceNoException(path) != null;
    }

    /**
     * Loads and returns a properties file from the context class loader.

        for (final String[] call : testClient.addMappingCalls) {
            assertNotNull(call);
        }
        // The loadBulkData=true path triggers getResourcePath + ResourceUtil.isExist checks.
        // In test environment resource files don't exist, so insertBulkData won't be called,
        // but the overall flow should still succeed.
        assertTrue(testClient.calledMethods.contains("addMapping"));

        runner.refresh();

        GetResponse getResponse =
                runner.client().prepareGet().setIndex(suggester.getIndex()).setId(item.getId()).get(TimeValue.timeValueSeconds(30));
        assertTrue(getResponse.isExists());
    }

    @Test
    public void test_writeItemsWithUpdate() throws Exception {
        String[][] readings = new String[1][];
        readings[0] = new String[] { "test" };

import importlib

import pytest
from dirty_equals import IsList
from fastapi.testclient import TestClient
from inline_snapshot import snapshot

from ...utils import needs_py310


@pytest.fixture(
    name="client",
    params=[
        pytest.param("tutorial005_py310", marks=needs_py310),
    ],
)
def get_client(request: pytest.FixtureRequest):
    mod = importlib.import_module(f"docs_src.body_nested_models.{request.param}")

    return ret;
  }
  status->status =
      tensorflow::AttrTypeByName(*attr_types_, attr_name, &ret, is_list);
  return ret;
}

TF_AttrType TFE_OpNameGetAttrType(TFE_Context* ctx,
                                  const char* op_or_function_name,
                                  const char* attr_name, unsigned char* is_list,
                                  TF_Status* status) {
  TF_AttrType ret;

        try {
            final GetResponse getResponse =
                    client.prepareGet().setIndex(settingsIndexName).setId(settingsId).execute().actionGet(getSearchTimeout());

            if (!getResponse.isExists()) {
                doCreate = true;
            }
        } catch (final IndexNotFoundException e) {
            doIndexCreate = true;
            doCreate = true;
        }

        if (doCreate) {

TF_CAPI_EXPORT extern TF_AttrType TFE_OpGetAttrType(TFE_Op* op,
                                                    const char* attr_name,
                                                    unsigned char* is_list,
                                                    TF_Status* status);
// Get an attribute type given an op name; a fusion of TFE_NewOp and
// TFE_OpGetAttrType for use from Python without the overhead of the individual

            final IndicesExistsResponse response =
                    client.admin().indices().prepareExists(getSearchAlias(index)).execute().actionGet(suggestSettings.getIndicesTimeout());
            if (!response.isExists()) {
                final String mappingSource = getDefaultMappings();
                final String settingsSource = getDefaultIndexSettings();
                final String indexName = createIndexName(index);

        boolean exists = false;
        try {
            final IndicesExistsResponse response = fesenClient.get(c -> c.admin().indices().prepareExists(index).execute());
            exists = response.isExists();
        } catch (final IndexNotFoundException e) {
            // ignore
        }
        if (!exists) {
            final CreateIndexResponse indexResponse = fesenClient.get(c -> {

        try {
            final IndicesExistsResponse response =
                    client.admin().indices().prepareExists(analyzerSettingsIndexName).execute().actionGet(settings.getIndicesTimeout());
            if (!response.isExists()) {
                createAnalyzerSettings(loadIndexSettings(), loadIndexMapping());
            }
            analyzerMap.put(analyzerSettingsIndexName, getAnalyzerNames());