implementation(libs.assertk)
        implementation(libs.conscrypt.openjdk)
        implementation(libs.junit.jupiter.api)
        implementation(libs.junit.jupiter.engine)
        implementation(libs.junit.jupiter.params)
        implementation(libs.junit.vintage.engine)
        implementation(libs.junit)
        implementation(libs.kotlin.test.annotations)
        implementation(libs.kotlin.test.common)

import org.jetbrains.dokka.gradle.DokkaExtension;
import org.jetbrains.dokka.gradle.DokkaPlugin;
import org.jetbrains.dokka.gradle.engine.parameters.DokkaSourceLinkSpec;
import org.jetbrains.dokka.gradle.engine.parameters.DokkaSourceSetSpec;
import org.jetbrains.dokka.gradle.engine.plugins.DokkaHtmlPluginParameters;
import org.jetbrains.dokka.gradle.tasks.DokkaGeneratePublicationTask;

import java.io.File;
import java.net.URI;

### Créer un engine { #create-an-engine }

Un `engine` SQLModel (en dessous c'est en fait un `engine` SQLAlchemy) est ce qui **détient les connexions** à la base de données.

Vous devez avoir **un seul objet `engine`** pour tout votre code afin de se connecter à la même base.

     * The template is evaluated using the specified script engine with the value and context.
     *
     * @param dataMap the data map to modify
     * @param key the key to store the processed value under
     * @param value the original value to process
     * @param template the template script to evaluate
     * @param scriptType the type of script engine to use
     */

                                    <tr>
                                        <th><la:message key="labels.joblog_endTime"/></th>
                                        <td>${f:h(endTime)}<la:hidden property="endTime"/></td>
                                    </tr>
                                    <tr>
                                        <th><la:message key="labels.joblog_scriptType"/></th>

### Create an Engine { #create-an-engine }

A SQLModel `engine` (underneath it's actually a SQLAlchemy `engine`) is what **holds the connections** to the database.

You would have **one single `engine` object** for all your code to connect to the same database.

### Eine Engine erstellen { #create-an-engine }

Eine SQLModel-`engine` (darunter ist es tatsächlich eine SQLAlchemy-`engine`) ist das, was die **Verbindungen** zur Datenbank hält.

Sie hätten **ein einziges `engine`-Objekt** für Ihren gesamten Code, um sich mit derselben Datenbank zu verbinden.

func (m *rateMeasurement) updateExponentialMovingAverage(endTime time.Time) {
	// Calculate aggregate avg bandwidth and exp window avg
	m.lock.Lock()
	defer func() {
		m.startTime = endTime
		m.lock.Unlock()
	}()

	if m.startTime.IsZero() {
		return
	}

	if endTime.Before(m.startTime) {
		return
	}

	duration := endTime.Sub(m.startTime)

    // ===================================================================================
    // Attribute
    // =========

    /** Client for interacting with the search engine. */
    @Resource
    protected SearchEngineClient searchEngineClient;

    /** Helper for building and parsing search queries. */
    @Resource
    protected QueryHelper queryHelper;

  api(libs.square.kotlin.poet)
  testImplementation(libs.assertk)
  testImplementation(libs.junit.jupiter.api)
  testImplementation(libs.junit.jupiter.params)

  testImplementation(rootProject.libs.junit.jupiter.engine)
}

animalsniffer {
  isIgnoreFailures = true