You could load it at the top level of the module/file, but that would also mean that it would **load the model** even if you are just running a simple automated test, then that test would be **slow** because it would have to wait for the model to load before being able to run an independent part of the code.

import org.slf4j.ILoggerFactory;

/**
 * Slf4jConfiguration factory, loading implementations from <code>META-INF/maven/slf4j-configuration.properties</code>
 * configuration files in class loader: key is the class name of the ILoggerFactory, value is the class name of
 * the corresponding Slf4jConfiguration.
 *
 * @since 3.1.0
 */
public class Slf4jConfigurationFactory {

if _running_from_pip_package():
  # TODO(gunan): Add sanity checks to loaded modules here.

  # Load first party dynamic kernels.
  _tf_dir = _os.path.dirname(_current_file_location)
  _kernel_dir = _os.path.join(_tf_dir, "core", "kernels")
  if _os.path.exists(_kernel_dir):
    _ll.load_library(_kernel_dir)

  # Load third party dynamic kernels.
  for _s in _site_packages_dirs:

        };

    cache.put(0, 10);

    assertThat(cache.get(0, loader)).isEqualTo(10);
    assertThat(cache.get(20, loader)).isEqualTo(1);
    assertThat(cache.get(34, loader)).isEqualTo(2);

    cache.invalidate(0);
    assertThat(cache.get(0, loader)).isEqualTo(3);

    cache.put(0, 10);
    cache.invalidateAll();
    assertThat(cache.get(0, loader)).isEqualTo(4);
  }

  @Test
  public void sizeConstraint() {

maven.project.conf      = ${session.rootDirectory}/.mvn

# Comma-separated list of files to include.
# Each item may be enclosed in quotes to gracefully include spaces. Items are trimmed before being loaded.
# If the first character of an item is a question mark, the load will silently fail if the file does not exist.
${includes} = ?"${maven.user.conf}/maven-system.properties", \
              ?"${maven.project.conf}/maven-system.properties"

#
# Settings

#

# Comma-separated list of files to include.
# Each item may be enclosed in quotes to gracefully include spaces. Items are trimmed before being loaded.
# If the first character of an item is a question mark, the load will silently fail if the file does not exist.
${includes} = ?"${maven.user.conf}/maven-user.properties", \
              ?"${maven.project.conf}/maven-user.properties"

#

        }

        return true;
    }

    /**
     * Loads properties from the file.
     */
    public synchronized void load() {
        final Properties prop = new Properties();
        try (final FileInputStream fis = new FileInputStream(propertiesFile)) {
            lastModified = propertiesFile.lastModified();
            prop.load(fis);
        } catch (final IOException e) {

            String.format("Verification failed: %d files contained %d violations", errors.keySet().size(), errors.values().size())
        );
        throw new GradleException(message);
    }

    /**
     * Loads the known keywords. Although the JSON on disk maps from language to keywords, this method
     * inverts this to map from keyword to languages. This is because the same keywords are found in

   * 1 MiB of response data is loaded into memory. (You could use any size here, though large values
   * risk exhausting memory.)
   *
   * This returns an empty value if the trailers are available, but have no data.
   *
   * It is not safe to call this concurrently with code that is processing the response body.
   *
   * @throws IOException if the trailers cannot be loaded, such as if the network connection is

          <type>String</type>
        </field>
        <field>
          <name>classLoadingStrategy</name>
          <description>The class loading strategy: 'self-first' (the default), 'parent-first' (loads classes from the parent, then from the extension) or 'plugin' (follows the rules from extensions defined as plugins).</description>
          <version>1.1.0+</version>
          <defaultValue>self-first</defaultValue>