{
    "description": "TensorFlow is an end-to-end open source platform for machine learning. It has a comprehensive, flexible ecosystem of tools, libraries, and community resources that lets researchers push the state-of-the-art in ML and developers easily build and deploy ML-powered applications.",
    "license": "Apache-2.0",
    "title": "TensorFlow",
    "upload_type": "software",
    "creators": [
        {
            "name": "TensorFlow Developers"
        }

New-Item -ItemType directory -Path $gradleInit
echo "Copy .ci/init.gradle to $gradleInit"
Copy-Item .ci/init.gradle -Destination $gradleInit

[Environment]::SetEnvironmentVariable("JAVA_HOME", $null, "Machine")
$env:PATH="C:\Users\jenkins\.java\$env:ES_BUILD_JAVA\bin\;$env:PATH"
$env:JAVA_HOME=$null
$env:SYSTEM_JAVA_HOME="C:\Users\jenkins\.java\$env:ES_RUNTIME_JAVA"
Remove-Item -Recurse -Force \tmp -ErrorAction Ignore

 * little-endian order.
 *
 * <p><b>Warning:</b> The result of calling any methods after calling {@link #hash} is undefined.
 *
 * <p><b>Warning:</b> Using a specific character encoding when hashing a {@link CharSequence} with
 * {@link #putString(CharSequence, Charset)} is generally only useful for cross-language
 * compatibility (otherwise prefer {@link #putUnencodedChars}). However, the character encodings

 * (Modified to adapt to Guava coding conventions and to use the HashFunction interface)
 */

package com.google.common.hash;

import static com.google.common.hash.Hashing.GOOD_FAST_HASH_SEED;
import static java.lang.Byte.toUnsignedInt;

import com.google.errorprone.annotations.Immutable;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

        assertEquals("Invalid LDAP parameter", exception.getCause().getCause().getMessage());
    }

    @Test
    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        String expectedMessage = "LDAP authentication failed";
        try {
            throw new LdapOperationException(expectedMessage);
        } catch (LdapOperationException e) {

        assertEquals(message, exception.getMessage());
        assertNull(exception.getCause());
    }

    @Test
    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        String message = "Thrown exception test";

        try {
            throw new ScriptEngineException(message);
        } catch (ScriptEngineException e) {

            xpackFileTree = xpackConfigToFileTree.apply(xpackConfig).matching(xpackPatternSet);
        }
        if (includeCore.get().isEmpty() == false) {
            corePatternSet.setIncludes(includeCore.get().stream().map(prefix -> prefix + "*/**").collect(Collectors.toList()));
            coreFileTree = coreConfigToFileTree.apply(coreConfig).matching(corePatternSet); // directory on disk
        }

import com.google.common.annotations.GwtCompatible;
import java.util.Iterator;
import org.jspecify.annotations.Nullable;

/**
 * An iterator that transforms a backing iterator; for internal use. This avoids the object overhead
 * of constructing a {@link com.google.common.base.Function Function} for internal methods.
 *
 * @author Louis Wasserman
 */
@GwtCompatible

先把那些資料放進 Pydantic 的 `UserInDB` 模型。

你絕對不要以純文字儲存密碼，所以我們會使用（假的）密碼雜湊系統。

如果密碼不匹配，我們回傳同樣的錯誤。

#### 密碼雜湊（hashing） { #password-hashing }

「雜湊」的意思是：把一些內容（這裡是密碼）轉換成一串看起來像亂碼的位元組序列（就是字串）。

只要你輸入完全相同的內容（完全相同的密碼），就會得到完全相同的亂碼。

但你無法從這串亂碼還原回原本的密碼。

##### 為何要做密碼雜湊 { #why-use-password-hashing }

如果你的資料庫被竊取，攻擊者拿到的不是使用者的純文字密碼，而只是雜湊值。

因此攻擊者無法嘗試把那些密碼用在其他系統上（因為很多使用者在各處都用同一組密碼，這會很危險）。

import org.codehaus.plexus.logging.Logger;
import org.codehaus.plexus.logging.LoggerManager;
import org.slf4j.ILoggerFactory;
import org.slf4j.LoggerFactory;

/**
 * Use an SLF4J {@link ILoggerFactory} as a backing for a Plexus
 * {@link LoggerManager},
 * ignoring Plexus logger API parts that are not classical and probably not really used.
 *
 * @since 3.1
 */
public class Slf4jLoggerManager implements LoggerManager {