}

nullaway {
    // NullAway can use NullMarked instead, but for the adoption process it is more effective to assume that all gradle code is already annotated.
    // This way we can catch discrepancies in modules easier. We should make all packages NullMarked eventually too, but this is a separate task.
    annotatedPackages.add("org.gradle")
}

dependencies {
    attributesSchema {

                        .getDestinationDir()
                        .toPath()
                        .resolve("elasticsearch-" + VersionProperties.getElasticsearch() + "/modules/x-pack-ml/NOTICE.txt");
                    final List<String> actualLines;
                    try {
                        actualLines = Files.readAllLines(noticePath);

  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>org.apache.maven</groupId>
    <artifactId>maven-compat-modules</artifactId>
    <version>4.1.0-SNAPSHOT</version>
  </parent>

  <artifactId>maven-compat</artifactId>

  <name>Maven Compat (deprecated)</name>

///

## Separating tests { #separating-tests }

In a real application, you probably would have your tests in a different file.

And your **FastAPI** application might also be composed of several files/modules, etc.

### **FastAPI** app file { #fastapi-app-file }

Let's say you have a file structure as described in [Bigger Applications](bigger-applications.md):

```
.
├── app
│   ├── __init__.py
│   └── main.py

				return 0, err
			}
			// We use a single recursive 'adb push' of the module root instead of
			// walking the tree and copying it piecewise. If the directory tree
			// contains nested modules this could push a lot of unnecessary contents,
			// but for the golang.org/x repos it seems to be significantly (~2x)
			// faster than copying one file at a time (via filepath.WalkDir),

      }
    }
  }

  tasks.register('buildDependencyArtifacts') {
    group = 'ide'
    description = 'Builds artifacts needed as dependency for IDE modules'
    dependsOn ':client:rest-high-level:shadowJar', ':plugins:repository-hdfs:hadoop-client-api:shadowJar', ':plugins:repository-azure:azure-storage-blob:shadowJar'
  }

  idea {
    project {
      vcs = 'Git'

running the `tf.train.Server`.

## Untrusted inputs during training and prediction

TensorFlow supports a wide range of input data formats. For example it can
process images, audio, videos, and text. There are several modules specialized
in taking those formats, modifying them, and/or converting them to intermediate
formats that can be processed by TensorFlow.

These modifications and conversions are handled by a variety of libraries that

     */
    @Nonnull
    Optional<String> alternatePomFile();

    /**
     * Indicates whether Maven should operate in non-recursive mode (i.e., not build child modules).
     *
     * @return an {@link Optional} containing true if non-recursive mode is enabled, false if disabled, or empty if not specified
     */
    @Nonnull
    Optional<Boolean> nonRecursive();

    /**

    "Programming Language :: Python",
    "Topic :: Internet",
    "Topic :: Software Development :: Libraries :: Application Frameworks",
    "Topic :: Software Development :: Libraries :: Python Modules",
    "Topic :: Software Development :: Libraries",
    "Topic :: Software Development",
    "Typing :: Typed",
    "Development Status :: 4 - Beta",
    "Environment :: Web Environment",
    "Framework :: AsyncIO",

      return Maps.transformValues(
          fromTable.columnMap(), column -> Maps.transformValues(column, function));
    }
  }

  /**
   * Returns an unmodifiable view of the specified table. This method allows modules to provide
   * users with "read-only" access to internal tables. Query operations on the returned table "read
   * through" to the specified table, and attempts to modify the returned table, whether direct or