package main

type Set[T comparable] map[T]struct{}

func NewSet[T comparable](values []T) Set[T] {
	set := make(Set[T])
	set.Add(values)
	return set
}

func (s Set[T]) Add(values []T) {
	for _, value := range values {
		s[value] = struct{}{}
	}
}

func (s Set[T]) Remove(value T) {
	delete(s, value)
}

func (s Set[T]) Contains(value T) bool {
	_, exists := s[value]
	return exists
}

func (s Set[T]) Size() int {
	return len(s)
}

func (s Set[T]) ToSlice() []T {
	slice := make([]T, 0, len(s))
	for value := range s {
		slice = append(slice, value)
	}
	return slice
}

package main

func main() {
    // 빈 Set 생성 후 슬라이스로 추가
    s := NewSet([]int{1, 2, 3}) // 여러 값 추가

    // 추가적인 값들을 슬라이스로 추가
    moreValues := []int{4, 5, 6}
    s.Add(moreValues) // 슬라이스를 전달하여 추가

    fmt.Println(s.Contains(1)) // true
    fmt.Println(s.Contains(6)) // true
    fmt.Println(s.Contains(7)) // false

    fmt.Println(s.Size()) // 6

    s.Remove(1)
    fmt.Println(s.Contains(1)) // false

    // 현재 Set의 값을 배열로 변환하여 출력
    fmt.Println(s.ToSlice()) // [2 3 4 5 6]
}

az account set --subscription "<구독 이름>"

az vm repair create -g RGNAME -n BROKENVMNAME --verbose

az vm repair run -g RGNAME -n BROKENVMNAME --run-id win-crowdstrike-fix-bootloop --run-on-repair --verbose

az vm repair restore -g RGNAME -n BROKENVMNAME --verbose

└── image-text-translator 
    ├── scripts/ - 환경 설정 및 도우미 스크립트 
    |└── setup.sh - 설정 도우미 스크립트 
    ├── app/ - 애플리케이션 
    │ ├── ui_cr/ - 브라우저 UI(Cloud Run) 
    │ │ ├── static/ - 프런트엔드용 정적 콘텐츠 
    | | ├── templates/ - 프런트엔드용 HTML 템플릿 
    | | ├── app.py - Flask 애플리케이션 
    | | ├── requirements.txt - UI Python requirements 
    | | ├── Dockerfile - Flask 컨테이너를 빌드하는 Dockerfile 
    | | └── .dockerignore - Dockerfile에서 무시할 파일 
    | | 
    │ └── backend_gcf/ - 백엔드(클라우드 함수) 
    │ ├── main.py - 백엔드 CF 애플리케이션 
    │ └── requirements.txt - 백엔드 CF Python 요구 사항 
    ├── requirements.txt - 프로젝트 로컬 개발에 대한 Python 요구 사항 
    └── README.md

# Google Cloud에 인증
gcloud auth list 

# 올바른 프로젝트를 선택했는지 확인 
export PROJECT_ID=<프로젝트 ID 입력> 
gcloud config set project $PROJECT_ID 

# Cloud Build API 사용
 gcloud services enable cloudbuild.googleapis.com 

# Cloud Storage API 사용
 gcloud services enable storage-api.googleapis.com 

# Artifact Registry API 사용
 gcloud services enable artifactregistry.googleapis.com 

# Eventarc API 사용
 gcloud services enable eventarc.googleapis.com 

# Cloud Run Admin API 사용
 gcloud services enable run.googleapis.com 

# Cloud Logging API 사용
 gcloud services enable logging.googleapis.com 

# Cloud Pub/Sub API 사용
 gcloud services enable pubsub.googleapis.com # 

Cloud Functions API
 사용 gcloud services enable cloudfunctions.googleapis.com 

# Cloud Translation API 사용
 gcloud services enable translate.googleapis.com 

# Cloud Vision API 사용
 gcloud services enable vision.googleapis.com 

# 서비스 계정 자격 증명 API 사용
 gcloud services enable iamcredentials.googleapis.com

# 이 작업을 하기 전에 PROJECT_ID 변수가 설정되어 있는지 확인하세요! 
export SVC_ACCOUNT=image-text-translator-sa 
export SVC_ACCOUNT_EMAIL= $SVC_ACCOUNT @ $PROJECT_ID .iam.gserviceaccount.com 

# 사용자 관리 서비스 계정을 연결하는 것은 Google Cloud에서 실행되는 프로덕션 코드에 대한 ADC에 자격 증명을 제공하는 가장 좋은 방법입니다.
 gcloud iam service-accounts create $SVC_ACCOUNT

# 서비스 계정에 역할 부여
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SVC_ACCOUNT_EMAIL" \
  --role=roles/run.admin

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SVC_ACCOUNT_EMAIL" \
  --role=roles/run.invoker

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SVC_ACCOUNT_EMAIL" \
  --role=roles/cloudfunctions.admin

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SVC_ACCOUNT_EMAIL" \
  --role=roles/cloudfunctions.invoker

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SVC_ACCOUNT_EMAIL" \
  --role="roles/cloudtranslate.user"

# 서비스 계정을 다른 리소스에 연결할 주체에게 필요한 역할을 부여합니다.
gcloud iam service-accounts add-iam-policy-binding $SVC_ACCOUNT_EMAIL \
  --member="group:gcp-devops@my-org.com" \
  --role=roles/iam.serviceAccountUser

# 서비스 계정 허용
gcloud iam service-accounts add-iam-policy-binding $SVC_ACCOUNT_EMAIL \
  --member="group:gcp-devops@my-org.com" \
  --role=roles/iam.serviceAccountTokenCreator

# 계정에 Cloud Functions 및 Cloud Run에 배포할 수 있는 액세스 권한이 있는지 확인합니다.
gcloud projects add-iam-policy-binding $PROJECT_ID \
   --member="group:gcp-devops@my-org.com" \
   --role roles/run.admin

# 로컬 Linux 환경에 Google Cloud CLI를 설치합니다. 
# https://cloud.google.com/sdk/docs/install을 참조하세요. # 

Gcloud CLI에서 Python 및 pip를 설정합니다. 
# https://cloud.google.com/python/docs/setup을 참조하세요. 

# 로컬 개발자를 위한 추가 Google Cloud CLI 패키지를 설치합니다.
sudo apt install google-cloud-cli-gke-gcloud-auth-plugin kubectl google-cloud-cli-skaffold google-cloud-cli-minikube

# Google Cloud에 인증합니다.
gcloud auth login

git clone https://github.com/hanhyeonkyu/image-text-translator.git

cd image-text-translator

python -m venv venv
source venv/bin/activate
pip install -r requirements.txt

gcloud auth application-default login

# 아직 설정하지 않은 경우... 
export SVC_ACCOUNT=image-text-translator-sa
export SVC_ACCOUNT_EMAIL=$SVC_ACCOUNT@$PROJECT_ID.iam.gserviceaccount.com

# 로컬 개발자를 위한 서비스 계정 키 생성
gcloud iam service-accounts keys create ~/.config/gcloud/$SVC_ACCOUNT.json \
  --iam-account=$SVC_ACCOUNT_EMAIL

# 클라이언트 라이브러리에서 자동으로 감지되는 ADC 환경변수
export GOOGLE_APPLICATION_CREDENTIALS=~/.config/gcloud/$SVC_ACCOUNT.json

export PROJECT_ID=$(gcloud config list --format='value(core.project)')
export REGION=europe-west4
export SVC_ACCOUNT=image-text-translator-sa
export SVC_ACCOUNT_EMAIL=$SVC_ACCOUNT@$PROJECT_ID.iam.gserviceaccount.com
export GOOGLE_APPLICATION_CREDENTIALS=~/.config/gcloud/$SVC_ACCOUNT.json

# Functions
export FUNCTIONS_PORT=8081
export BACKEND_GCF=https://$REGION-$PROJECT_ID.cloudfunctions.net/extract-and-translate

# Flask
export FLASK_SECRET_KEY=some-secret-1234
export FLASK_RUN_PORT=8080

echo "Environment variables configured:"
echo PROJECT_ID="$PROJECT_ID"
echo REGION="$REGION"
echo SVC_ACCOUNT_EMAIL="$SVC_ACCOUNT_EMAIL"
echo BACKEND_GCF="$BACKEND_GCF"
echo FUNCTIONS_PORT="$FUNCTIONS_PORT"
echo FLASK_RUN_PORT="$FLASK_RUN_PORT"

@functions_framework.http
def extract_and_translate(request):
    """Extract and translate the text from an image.
    The image can be POSTed in the request, or it can be a GCS object reference.
    
    If a POSTed image, enctype should be multipart/form-data and the file named 'uploaded'.
    If we're passing a GCS object reference, content-type should be 'application/json', 
    with two attributes:
    - bucket: name of GCS bucket in which the file is stored.
    - filename: name of the file to be read.
    """

    # Check if the request method is POST
    if request.method == 'POST':
        # Get the uploaded file from the request
        uploaded = request.files.get('uploaded')  # Assuming the input filename is 'uploaded'
        to_lang = request.form.get('to_lang', "en")
        print(f"{uploaded=}, {to_lang=}")
        if not uploaded:
            return flask.jsonify({"error": "No file uploaded."}), 400

        if uploaded: # Process the uploaded file
            file_contents = uploaded.read()  # Read the file contents
            image = vision.Image(content=file_contents)
        else:
            return flask.jsonify({"error": "Unable to read uploaded file."}), 400
    else:
        # If we haven't created this, then get it from the bucket instead
        content_type = request.headers.get('content-type', 'null')
        if content_type == 'application/json':
            bucket = request.json.get('bucket', None)
            filename = request.json.get('filename', None)
            to_lang = request.json.get('to_lang', "en")

            print(f"Received {bucket=}, {filename=}, {to_lang=}")
        else:
            return flask.jsonify({"error": "Unknown content type."}), 400

        if bucket:
            image = vision.Image(source=vision.ImageSource(gcs_image_uri=f"gs://{bucket}/{filename}"))

    # Use the Vision API to extract text from the image
    detected = detect_text(image)
    if detected:
        translated = translate_text(detected, to_lang)
        if translated["text"] != "":
            # print(translated)
            return translated["text"]

    return "No text found in the image."

def detect_text(image: vision.Image) -> dict | None:
    """Extract the text from the Image object """
    text_detection_response = vision_client.text_detection(image=image)
    annotations = text_detection_response.text_annotations

    if annotations:
        text = annotations[0].description
    else:
        text = ""
    # print(f"Extracted text from image:\n{text}")

    # Returns language identifer in ISO 639-1 format. E.g. en.
    # See https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes
    detect_language_response = translate_client.detect_language(text)
    src_lang = detect_language_response["language"]
    print(f"Detected language: {src_lang}.")

    message = {
        "text": text,
        "src_lang": src_lang,
    }

    return message

def translate_text(message: dict, to_lang: str) -> dict:
    """
    Translates the text in the message from the specified source language
    to the requested target language, then sends a message requesting another
    service save the result.
    """

    text = message["text"]
    src_lang = message["src_lang"]

    translated = { # before translating
        "text": text,
        "src_lang": src_lang,
        "to_lang": to_lang,
    }

    if src_lang != to_lang and src_lang != "und":
        print(f"Translating text into {to_lang}.")
        translated_text = translate_client.translate(
                text, target_language=to_lang, source_language=src_lang)

        translated = {
            "text": unescape(translated_text["translatedText"]),
            "src_lang": src_lang,
            "to_lang": to_lang,
        }
    else:
        print("No translation required.")

    return translated

# Run the function
functions-framework --target extract_and_translate \
  --debug --port $FUNCTIONS_PORT

# You will first need to authenticate and set the environment vars in this terminal
source ./scripts/setup.sh

# now invoke
curl -X POST localhost:$FUNCTIONS_PORT \
   -H "Content-Type: multipart/form-data" \
   -F "uploaded=@./testing/images/kr_meme.jpg" \
   -F "to_lang=en"

# From the backend-gcf folder
gcloud functions deploy extract-and-translate \
  --gen2 --max-instances 1 \
  --region $REGION \
  --runtime=python312 --source=. \
  --trigger-http --entry-point=extract_and_translate \
  --no-allow-unauthenticated

# Allow this function to be called by the service account
gcloud functions add-invoker-policy-binding extract-and-translate \
  --region=$REGION \
  --member="serviceAccount:$SVC_ACCOUNT_EMAIL"

curl -X POST https://$REGION-$PROJECT_ID.cloudfunctions.net/extract-and-translate \
    -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
    -H "Content-Type: multipart/form-data" \
    -F "uploaded=@./testing/images/ua_meme.jpg" \
    -F "to_lang=en"

gcloud functions delete extract-and-translate --region=$REGION

export IMAGE_NAME=$REGION-docker.pkg.dev/$PROJECT_ID/image-text-translator-artifacts/image-text-translator-ui

# configure Docker to use the Google Cloud CLI to authenticate requests to Artifact Registry.
gcloud auth configure-docker $REGION-docker.pkg.dev

# Build the image and push it to Artifact Registry
# Run from the ui_cr folder
gcloud builds submit --tag $IMAGE_NAME:v0.1 .

# create a random secret key for our Flask application
export RANDOM_SECRET_KEY=$(openssl rand -base64 32)

gcloud run deploy image-text-translator-ui \
  --image=$IMAGE_NAME:v0.1 \
  --region=$REGION \
  --platform=managed \
  --allow-unauthenticated \
  --max-instances=1 \
  --service-account=$SVC_ACCOUNT \
  --set-env-vars BACKEND_GCF=$BACKEND_GCF,FLASK_SECRET_KEY=$RANDOM_SECRET_KEY

# Check our IMAGE_NAME is set
export IMAGE_NAME=$REGION-docker.pkg.dev/$PROJECT_ID/image-text-translator-artifacts/image-text-translator-ui
# Set our new version number
export VERSION=v0.2

# Rebuild the container image and push to the GAR
gcloud builds submit --tag $IMAGE_NAME:$VERSION .

# create a random secret key for our Flask application
export RANDOM_SECRET_KEY=$(openssl rand -base64 32)

# Redeploy
gcloud run deploy image-text-translator-ui \
  --image=$IMAGE_NAME:$VERSION \
  --region=$REGION \
  --platform=managed \
  --allow-unauthenticated \
  --max-instances=1 \
  --service-account=$SVC_ACCOUNT \
  --set-env-vars BACKEND_GCF=$BACKEND_GCF,FLASK_SECRET_KEY=$RANDOM_SECRET_KEY

# Verify your domain ownership with Google
gcloud domains verify mydomain.com
# Check it
gcloud domains list-user-verified

# Create a mapping to your domain
gcloud beta run domain-mappings create \
  --region $REGION \
  --service image-text-translator-ui \
  --domain image-text-translator.mydomain.com
  
# Obtain the DNS records. We want everything under `resourceRecords`.
gcloud beta run domain-mappings describe \
  --region $REGION \
  --domain image-text-translator.mydomain.com

gcloud services enable spanner.googleapis.com,functions.googleapis.com,run.googleapis.com,compute.googleapis.com

CREATE TABLE patents_data ( id VARCHAR(25), type VARCHAR(25), number VARCHAR(20), country VARCHAR(2), date VARCHAR(20), abstract VARCHAR(300000), title VARCHAR(100000), kind VARCHAR(5), num_claims BIGINT, filename VARCHAR(100), withdrawn BIGINT) ;

CREATE EXTENSION vector;
CREATE EXTENSION google_ml_integration;

GRANT EXECUTE ON FUNCTION embedding TO postgres;

ALTER TABLE patents_data ADD column abstract_embeddings vector(768);

SELECT embedding( 'textembedding-gecko@003', 'AlloyDB is a managed, cloud-hosted SQL database service.');

UPDATE patents_data set abstract_embeddings = embedding( 'textembedding-gecko@003', abstract);

SELECT id || ' - ' || title as literature FROM patents_data ORDER BY abstract_embeddings <=> embedding('textembedding-gecko@003', 'A new Natural Language Processing related Machine Learning Model')::vector LIMIT 10;

<!-- Add the connector with the latest version -->
<dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>alloydb-jdbc-connector</artifactId>
  <version>1.1.1</version>
</dependency>

<!-- Add the driver with the latest version -->
<dependency>
  <groupId>org.postgresql</groupId>
  <artifactId>postgresql</artifactId>
  <version>42.6.0</version>
</dependency>

String ALLOYDB_DB = "postgres";
String ALLOYDB_USER = "postgres";
String ALLOYDB_PASS = "*****";
String ALLOYDB_INSTANCE_NAME = "projects/<<YOUR_PROJECT_ID>>/locations/us-central1/clusters/<<YOUR_CLUSTER>>/instances/<<YOUR_INSTANCE>>";
//Replace YOUR_PROJECT_ID, YOUR_CLUSTER, YOUR_INSTANCE with your actual values
Note that the function expects the search text as input parameter with key "search" and in this implementation, we are returning only one closest match from the database:

// Get the request body as a JSON object.
JsonObject requestJson = new Gson().fromJson(request.getReader(), JsonObject.class);
String searchText = requestJson.get("search").getAsString();

//Sample searchText: "A new Natural Language Processing related Machine Learning Model";
BufferedWriter writer = response.getWriter();
String result = "";
HikariDataSource dataSource = AlloyDbJdbcConnector();

try (Connection connection = dataSource.getConnection()) {
    //Retrieve Vector Search by text (converted to embeddings) using "Cosine Similarity" method
    try (PreparedStatement statement = connection.prepareStatement("SELECT id || ' - ' || title as literature FROM patents_data ORDER BY abstract_embeddings <=> embedding('textembedding-gecko@003', '" + searchText + "' )::vector LIMIT 1")) {
      ResultSet resultSet = statement.executeQuery();
      resultSet.next();
      String lit = resultSet.getString("literature");
      result = result + lit + "\n";
      System.out.println("Matching Literature: " + lit);
  }
writer.write("Here is the closest match: " + result);
}

cd alloydb-pgvector

gcloud functions deploy patent-search - gen2 - region=us-central1 - runtime=java11 - source=. - entry-point=cloudcode.helloworld.HelloWorld - trigger-http

gcloud functions call patent-search - region=us-central1 - gen2 - data '{"search": "A new Natural Language Processing related Machine Learning Model"}'

{"search": "A new Natural Language Processing related Machine Learning Model"}