migrate: GCP to Hugging Face

.dockerignore

@@ -0,0 +1,27 @@
+# Development
+/venv
+
+Makefile
+.env-example
+Docpet_Backend.code-workspace
+
+# Git & Github
+/.github
+
+README.md
+.gitignore
+
+# Terraform
+/.terraform
+/modules
+
+main.tf
+modules.tf
+variables.tf
+.terraform.lock.hcl
+
+# Docker
+/deployment
+
+.dockerignore
+docker-compose.yml

.env-example

@@ -0,0 +1,15 @@
+DATABASE_PORT=6500
+POSTGRES_PASSWORD=password123
+POSTGRES_USER=postgres
+POSTGRES_DB=docpet
+POSTGRES_HOST=postgres
+POSTGRES_HOSTNAME=127.0.0.1
+
+ACCESS_TOKEN_EXPIRES_IN=15
+REFRESH_TOKEN_EXPIRES_IN=60
+JWT_ALGORITHM=RS256
+
+CLIENT_ORIGIN=http://localhost:3000
+
+JWT_PRIVATE_KEY=LS0tLS1CRUdJTiBSU0EgUFJJVkFURSBLRVktLS0tLQpNSUlCT2dJQkFBSkJBSSs3QnZUS0FWdHVQYzEzbEFkVk94TlVmcWxzMm1SVmlQWlJyVFpjd3l4RVhVRGpNaFZuCi9KVHRsd3h2a281T0pBQ1k3dVE0T09wODdiM3NOU3ZNd2xNQ0F3RUFBUUpBYm5LaENOQ0dOSFZGaHJPQ0RCU0IKdmZ2ckRWUzVpZXAwd2h2SGlBUEdjeWV6bjd0U2RweUZ0NEU0QTNXT3VQOXhqenNjTFZyb1pzRmVMUWlqT1JhUwp3UUloQU84MWl2b21iVGhjRkltTFZPbU16Vk52TGxWTW02WE5iS3B4bGh4TlpUTmhBaUVBbWRISlpGM3haWFE0Cm15QnNCeEhLQ3JqOTF6bVFxU0E4bHUvT1ZNTDNSak1DSVFEbDJxOUdtN0lMbS85b0EyaCtXdnZabGxZUlJPR3oKT21lV2lEclR5MUxaUVFJZ2ZGYUlaUWxMU0tkWjJvdXF4MHdwOWVEejBEWklLVzVWaSt6czdMZHRDdUVDSUVGYwo3d21VZ3pPblpzbnU1clBsTDJjZldLTGhFbWwrUVFzOCtkMFBGdXlnCi0tLS0tRU5EIFJTQSBQUklWQVRFIEtFWS0tLS0t
+JWT_PUBLIC_KEY=LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUZ3d0RRWUpLb1pJaHZjTkFRRUJCUUFEU3dBd1NBSkJBSSs3QnZUS0FWdHVQYzEzbEFkVk94TlVmcWxzMm1SVgppUFpSclRaY3d5eEVYVURqTWhWbi9KVHRsd3h2a281T0pBQ1k3dVE0T09wODdiM3NOU3ZNd2xNQ0F3RUFBUT09Ci0tLS0tRU5EIFBVQkxJQyBLRVktLS0tLQ==

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+ml_models/*.h5 filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.github/workflows/pipeline.yaml

@@ -0,0 +1,50 @@
+name: pipeline
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - '*'
+
+jobs:
+  backend_deployment:
+    name: Backend Deployment
+    runs-on: ubuntu-latest
+    environment: Production
+
+    env:
+      HF_TOKEN: ${{ secrets.HF_TOKEN }}
+      SPACE_NAME: docpet_backend_service
+      HF_USERNAME: qywok
+
+    steps:
+      - name: Set global directory
+        run: git config --global --add safe.directory /github/workspace
+
+      - uses: actions/checkout@v3     
+        with:
+          persist-credentials: false
+          fetch-depth: 1000
+
+      - name: Check git status
+        run: git status
+
+      - name: Configure git
+        run: |
+          git config --local user.email "alfariqyraihan@gmail.com"
+          git config --local user.name "qywok"
+
+      - name: Pull changes from remote
+        run: |
+          git pull https://$HF_USERNAME:$HF_TOKEN@huggingface.co/spaces/$HF_USERNAME/$SPACE_NAME main || \
+          (git merge --strategy-option theirs)
+
+      - name: Add and commit changes
+        run: |
+          git add -A 
+          git diff-index --quiet HEAD || git commit -m "Backend Deployment"
+
+      - name: Push to Hugging Face
+        run: |
+          git push https://$HF_USERNAME:$HF_TOKEN@huggingface.co/spaces/$HF_USERNAME/$SPACE_NAME main --force

.github/workflows/production.yaml

@@ -0,0 +1,140 @@
+name: Production Pipeline
+
+on:
+  push:
+    branches:
+      - aiueo
+    tags:
+      - '*'
+
+permissions:
+  contents: read
+
+jobs:
+  # Build
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    environment: Production
+
+    env:
+      service: docpet-backend-service
+      project_id: docpet-project-ch2-ps068
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+      
+    - id: 'auth'
+      uses: 'google-github-actions/auth@v1'
+      with:
+        credentials_json: ${{ secrets.CONTAINER_REGISTRY_CREDENTIAL }}
+
+    - name: Setup Google Cloud
+      uses: google-github-actions/setup-gcloud@v1
+
+    - name: Setup Docker
+      run: gcloud auth configure-docker --quiet
+
+    # Push Docker Image to Google Container Registry
+    # --- DEPRECATED ---
+    # Container Registry is deprecated. After May 15, 2024,
+    # Artifact Registry will host images for the gcr.io domain
+    # in projects without previous Container Registry usage.
+    - name: Push Docker Image to Google Container Registry
+      run: |
+        git clone https://github.com/CH2-PS068/Docpet_Backend
+        cd Docpet_Backend
+
+        echo '${{ secrets.GOOGLE_BUCKET_CREDENTIAL }}' > sa_bucket.json
+
+        sed -i 's/docpet-project-ch2-ps068-a53f10c5c713.json/sa_bucket.json/g' app/gcs.py
+
+        docker build --tag $service:latest \
+          --file deployment/production.dockerfile .
+
+        docker tag $service:latest \
+          gcr.io/$project_id/$service:latest
+
+        docker push gcr.io/$project_id/$service:latest
+
+    # - name: Push Docker Image to Google Artifact Registry
+    #   env:
+    #     GOOGLE_PROJECT: ${{ secrets.GOOGLE_PROJECT }}
+    #   run: |
+    #     gcloud auth configure-docker asia-southeast2-docker.pkg.dev
+    #     docker build -t asia-southeast2-docker.pkg.dev/$GOOGLE_PROJECT/capstone/nginx:latest .
+    #     docker push asia-southeast2-docker.pkg.dev/$GOOGLE_PROJECT/capstone/nginx:latest
+
+  # Deploy
+  deploy:
+    name: Deploy
+    runs-on: ubuntu-latest
+    needs: build
+
+    env:
+      service: docpet-backend-service
+      project_id: docpet-project-ch2-ps068
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+      
+    - id: 'auth'
+      uses: 'google-github-actions/auth@v1'
+      with:
+        credentials_json: ${{ secrets.CLOUD_RUN_CREDENTIAL }}
+
+    - name: Setup Google Cloud
+      uses: google-github-actions/setup-gcloud@v1
+
+    # Deploy to Google Cloud Run
+    - name: Deploy to Google Cloud Run
+      run: |
+        gcloud run services delete docpet-backend-service --platform=managed \
+          --region=asia-southeast2 --quiet
+
+        gcloud secrets delete postgres-password-secret \
+          --project=docpet-project-ch2-ps068 --quiet
+
+        gcloud secrets delete private-key-secret \
+          --project=docpet-project-ch2-ps068 --quiet
+
+        gcloud secrets delete public-key-secret \
+          --project=docpet-project-ch2-ps068 --quiet
+
+        git clone https://github.com/CH2-PS068/Docpet_Backend
+        cd Docpet_Backend
+
+        terraform init
+
+        terraform apply -no-color -auto-approve \
+          -var="service_account=${{ secrets.SERVICE_ACCOUNT }}" \
+          -var="service_container=gcr.io/$project_id/$service:latest" \
+          -var="vpc_access_connector=test" \
+          -var="postgres_password=${{ secrets.POSTGRES_PASSWORD }}" \
+          -var="postgres_port=${{ secrets.POSTGRES_PORT }}" \
+          -var="postgres_user=${{ secrets.POSTGRES_USER }}" \
+          -var="postgres_db=${{ secrets.POSTGRES_DB }}" \
+          -var="postgres_host=${{ secrets.POSTGRES_HOST }}" \
+          -var="postgres_hostname=${{ secrets.POSTGRES_HOSTNAME }}" \
+          -var="access_token_expires=${{ secrets.ACCESS_TOKEN_EXP }}" \
+          -var="refresh_token_expires=${{ secrets.REFRESH_TOKEN_EXP }}" \
+          -var="jwt_algorithm=${{ secrets.JWT_ALGORITHM }}" \
+          -var="jwt_public_key=${{ secrets.JWT_PUBLIC_KEY }}" \
+          -var="jwt_private_key=${{ secrets.JWT_PRIVATE_KEY }}"
+
+    # Push the latest Info to Discord 
+    - name: Push the latest Info to Discord
+      run: |
+        ENDPOINT=$(gcloud run services describe docpet-backend-service \
+          --platform=managed --region=asia-southeast2 \
+          --format="value(status.url)")
+
+        wget https://raw.githubusercontent.com/CH2-PS068/Docpet_Infra/main/services/deploy_info_service/push_notif.lua
+
+        sudo apt install -y lua5.4
+        sudo apt install -y luarocks
+        sudo luarocks install dkjson
+
+        lua push_notif.lua "${{ secrets.DISCORD_ID }}" "${{ secrets.DISCORD_TOKEN }}" "${{ github.event.head_commit.message }}" "${{ github.event.head_commit.timestamp }}" "$ENDPOINT"

.github/workflows/staging.yaml

@@ -0,0 +1,152 @@
+name: Production Pipeline
+
+on:
+  push:
+    branches:
+      - aiueo
+    tags:
+      - '*'
+
+permissions:
+  contents: read
+
+jobs:
+  # Testing
+  testing:
+    name: Testing
+    runs-on: ubuntu-latest
+    environment: testing
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+
+    - name: Unit Testing
+      run: |
+        pip3 install nose2 nose2[coverage_plugin] scikit-learn \
+          numpy keras tensorflow keras_preprocessing
+          
+        nose2 --start-dir tests \
+          --verbose \
+          --pretty-assert \
+          --with-coverage
+
+  # Build
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    environment: build
+    needs: testing
+
+    env:
+      version: latest
+      service: ml-service
+      region: asia-southeast2
+      project_id: ${{ secrets.GOOGLE_PROJECT }}
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+      
+    - id: 'auth'
+      uses: 'google-github-actions/auth@v1'
+      with:
+        credentials_json: ${{ secrets.CONTAINER_REGISTRY_CREDENTIAL }}
+
+    - name: Setup Google Cloud
+      uses: google-github-actions/setup-gcloud@v1
+
+    - name: Setup Docker
+      run: gcloud auth configure-docker --quiet
+
+    # Push Docker Image to Google Container Registry
+    # --- DEPRECATED ---
+    # Container Registry is deprecated. After May 15, 2024,
+    # Artifact Registry will host images for the gcr.io domain
+    # in projects without previous Container Registry usage.
+    - name: Push Docker Image to Google Container Registry
+      run: |
+        git clone https://github.com/belajarqywok/fastapi-tensorflow-jaeger
+        cd fastapi-tensorflow-jaeger
+
+        docker build --tag $service:$version \
+          --file deployment/development.dockerfile .
+
+        docker tag $service:$version \
+          gcr.io/$project_id/$service:$version
+
+        docker push gcr.io/$project_id/$service:$version
+
+    # - name: Push Docker Image to Google Artifact Registry
+    #   env:
+    #     GOOGLE_PROJECT: ${{ secrets.GOOGLE_PROJECT }}
+    #   run: |
+    #     gcloud auth configure-docker asia-southeast2-docker.pkg.dev
+    #     docker build -t asia-southeast2-docker.pkg.dev/$GOOGLE_PROJECT/capstone/nginx:latest .
+    #     docker push asia-southeast2-docker.pkg.dev/$GOOGLE_PROJECT/capstone/nginx:latest
+
+  # Deploy
+  deploy:
+    name: Deploy
+    runs-on: ubuntu-latest
+    environment: deploy
+    needs: build
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+      
+    - id: 'auth'
+      uses: 'google-github-actions/auth@v1'
+      with:
+        credentials_json: ${{ secrets.CLOUD_RUN_CREDENTIAL }}
+
+    - name: Setup Google Cloud
+      uses: google-github-actions/setup-gcloud@v1
+
+    # Deploy to Google Cloud Run
+    - name: Deploy to Google Cloud Run
+      uses: 'google-github-actions/deploy-cloudrun@v1'
+      id: deploy-cloud-run
+      with:
+        service: ml-service
+        image: gcr.io/${{ secrets.GOOGLE_PROJECT }}/ml-service:latest
+        region: asia-southeast2
+        flags: |
+          --cpu=4 
+          --port=80 
+          --cpu-boost 
+          --memory=4Gi 
+          --timeout=800 
+          --concurrency=80
+          --min-instances=0 
+          --max-instances=13 
+          --project=${{ secrets.GOOGLE_PROJECT }} 
+          --allow-unauthenticated 
+          --vpc-egress=private-ranges-only 
+          --vpc-connector=projects/${{ secrets.GOOGLE_PROJECT }}/locations/asia-southeast2/connectors/ml-service-connector
+          --service-account=${{ secrets.CLOUD_RUN_SA }} 
+
+        env_vars: |
+          VERSION=v1
+          JWT_ACCESS_TOKEN_SECRET=${{ secrets.JWT_ACCESS_TOKEN_SECRET }}
+          JWT_REFRESH_TOKEN_SECRET=${{ secrets.JWT_REFRESH_TOKEN_SECRET }}
+          JWT_ALGORITHM=${{ secrets.JWT_ALGORITHM }}
+          JWT_ACCESS_TOKEN_EXPIRE=${{ secrets.JWT_ACCESS_TOKEN_EXPIRE }}
+          JWT_REFRESH_TOKEN_EXPIRE=${{ secrets.JWT_REFRESH_TOKEN_EXPIRE }}
+          POSTGRES_HOST=${{ secrets.POSTGRES_HOST }}
+          POSTGRES_PORT=${{ secrets.POSTGRES_PORT }}
+          POSTGRES_USER=${{ secrets.POSTGRES_USER }}
+          POSTGRES_PASS=${{ secrets.POSTGRES_PASS }}
+          POSTGRES_DB=${{ secrets.POSTGRES_DB }}
+
+    # Deploy to Google Cloud Run
+    - name: Deploy to Google Cloud Run
+      uses: 'google-github-actions/deploy-cloudrun@v1'
+      id: deploy-cloud-run
+
+    - name: Cloud Run URL Output
+      run: echo "${{ steps.deploy-cloud-run.outputs.url }}"
+
+    - name: Send Discord Notification
+      run: echo "send notification"

.gitignore

@@ -0,0 +1,141 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Terraform
+/.terraform/providers/registry.terraform.io
+
+# Credentials
+docpet-project-ch2-ps068-a53f10c5c713.json
+container-registry-sa.json
+cloudrun-sa.json
+
+# Development
+envtest.bat
+activate.bat

.terraform.lock.hcl

@@ -0,0 +1,22 @@
+# This file is maintained automatically by "terraform init".
+# Manual edits may be lost in future updates.
+
+provider "registry.terraform.io/hashicorp/google" {
+  version     = "5.6.0"
+  constraints = "5.6.0"
+  hashes = [
+    "h1:9eXuahX5uApOxDb/3ywewY9Eja2MAvyb9bplbyBW218=",
+    "zh:102b6a2672fade82114eb14ed46923fb1b74be2aaca3a50b4f35f7057a9a94b9",
+    "zh:1a56b63175068c67efbe7d130986ba2839a938f5ffc96a14fd450153174dbfa3",
+    "zh:1ba1c5e0c86e8aaa8037406390846e78c89b63faf9e527c7874641f35d436e1b",
+    "zh:3f7161b9288b47cbe89d2f9675f78d83b58ad5880c793b01f50a71ee2583844b",
+    "zh:66912d6e4180dac37185d17424b345a9d4e3c3c791d45e0737b35e32c9536b35",
+    "zh:6f06f56e9fac2e55b50e74ffac42d9522bb379394e51dca1eddd4c3b7a68545c",
+    "zh:8741861ebfa13bb1ed74ea7f4865388a0725ca3a781b6d873ce45e6a4630fe41",
+    "zh:ae89a9c538665fbc30bb83aa3b13acb18d8380e551ccf242e1c0ab4d626089ab",
+    "zh:c510f8321c7599aa601b1870fdc0c76cbad3054ed5cc70fe8e37a13a8046a71f",
+    "zh:cf143a53d5a25c6216d09a9c0b115bb473ffcebd5c4c62b2b2594b1ebc13e662",
+    "zh:de05b957e5dfdbaf92db47cd9b3ef46a0f8d94599eea6d472928f33058856add",
+    "zh:f569b65999264a9416862bca5cd2a6177d94ccb0424f3a4ef424428912b9cb3c",
+  ]
+}

.terraform/modules/modules.json

@@ -0,0 +1 @@
+{"Modules":[{"Key":"","Source":"","Dir":"."},{"Key":"access_token_secret","Source":"./modules/secrets","Dir":"modules/secrets"},{"Key":"db_password_secret","Source":"./modules/secrets","Dir":"modules/secrets"},{"Key":"docpet_service_cloud_run","Source":"./modules/cloud_run","Dir":"modules/cloud_run"},{"Key":"pgsql_password_secret","Source":"./modules/secrets","Dir":"modules/secrets"},{"Key":"postgres_password_secret","Source":"./modules/secrets","Dir":"modules/secrets"},{"Key":"private_key_secret","Source":"./modules/secrets","Dir":"modules/secrets"},{"Key":"public_key_secret","Source":"./modules/secrets","Dir":"modules/secrets"},{"Key":"refresh_token_secret","Source":"./modules/secrets","Dir":"modules/secrets"}]}

.terraform/terraform.tfstate

@@ -0,0 +1,30 @@
+{
+    "version": 3,
+    "serial": 1,
+    "lineage": "481f8758-12d3-9684-b4c4-6c3284d1905a",
+    "backend": {
+        "type": "gcs",
+        "config": {
+            "access_token": null,
+            "bucket": "docpet-terraform-state-store",
+            "credentials": null,
+            "encryption_key": null,
+            "impersonate_service_account": null,
+            "impersonate_service_account_delegates": null,
+            "kms_encryption_key": null,
+            "prefix": null,
+            "storage_custom_endpoint": null
+        },
+        "hash": 18446744071998496525
+    },
+    "modules": [
+        {
+            "path": [
+                "root"
+            ],
+            "outputs": {},
+            "resources": {},
+            "depends_on": []
+        }
+    ]
+}

Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.9-bullseye
+
+LABEL organization="docpet"
+LABEL team="cloud-computing-team"
+LABEL backend_engineer="Putu Wira Pratama Putra"
+LABEL Infra_engineer="Al-Fariqy Raihan Azhwar"
+
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+
+RUN useradd -m -u 1000 user
+USER user
+
+WORKDIR /etc/docpet_backend_service
+
+RUN python3 -m pip install --upgrade pip
+
+COPY --chown=user requirements/linux.requirements.txt \
+    /etc/docpet_backend_service/
+
+RUN pip3 install -r linux.requirements.txt
+
+COPY --chown=user . /etc/docpet_backend_service/
+
+RUN wget -O /etc/docpet_backend_service/ml_models/model.h5 \
+  https://github.com/belajarqywok/mbadhog/raw/main/model.h5
+
+EXPOSE 7860
+
+CMD [ "/bin/bash", "-c", "alembic upgrade head && uvicorn app:app --host 0.0.0.0 --port 7860 --workers 30" ]

Docpet_Backend.code-workspace

@@ -0,0 +1,8 @@
+{
+	"folders": [
+		{
+			"path": "."
+		}
+	],
+	"settings": {}
+}

Makefile

@@ -0,0 +1,5 @@
+dev:
+	docker-compose up -d
+
+dev-down:
+	docker-compose down

README.md

@@ -0,0 +1,98 @@
+---
+title: Docpet Backend Service
+emoji: 👨‍⚕️
+colorFrom: purple
+colorTo: green
+sdk: docker
+python_version: "3.9"
+app_file: app.py
+pinned: false
+---
+
+# Backend with FastAPI Docker Setup Guide
+
+This guide walks you through setting up a FastAPI project with PostgreSQL using Docker and integrating Alembic for database migrations.
+
+## Prerequisites
+
+- Docker installed on your machine
+- Python and pip install
+```bash
+pip install -r requirements.txt
+```
+
+## Step 1: Init and Setup Project
+
+Run the following commands in your terminal:
+
+```bash
+docker-compose up -d
+docker-compose down
+```
+
+## Step 2: Start PostgreSQL Docker Container
+```bash
+pip install fastapi[all]
+pip install sqlalchemy psycopg2
+```
+
+## Step 3: Start FastAPI Server
+```bash
+uvicorn app.main:app --host localhost --port 8000 --reload
+```
+
+Make a GET request to http://localhost:8000/api/healthchecker in Postman or any API testing tool to verify the response:
+```bash
+{
+    "message": "Hello World!"
+}
+```
+## Step 4: access the PostgreSQL Command Line in the Docker container and create admin role and grant
+```bash
+docker exec -it postgres psql -U postgres
+
+CREATE USER admin WITH PASSWORD 'your_password';
+
+GRANT ALL PRIVILEGES ON DATABASE docpet TO admin;
+```
+
+## Step 5: Access PostgreSQL Docker Container Shell
+```bash
+docker exec -it <container name> bash
+```
+
+Access the running Postgres database with the command:
+```bash
+psql -U admin <database name>
+```
+
+## Step 6: Install uuid-ossp Plugin
+Execute the following SQL command to display and install the uuid-ossp extension:
+```bash
+select * from pg_available_extensions;
+
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+```
+
+## Step 7: Initialize Alembic for Database Migrations
+Execute the following SQL command to display and install the uuid-ossp extension:
+```bash
+pip install alembic
+alembic init alembic
+```
+
+## Step 8: Create a Revision File for Database Changes
+```bash
+alembic revision --autogenerate -m "create users table"
+```
+
+## Step 9: Apply Database Changes
+```bash
+alembic upgrade head
+```
+
+## Step 10: View Documentation
+FastAPI automatically generates API documentation complying with OpenAPI standards.
+```bash
+Visit http://localhost:8000/docs to explore the API documentation.
+```

alembic.ini

@@ -0,0 +1,105 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+script_location = alembic
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = .
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python-dateutil library that can be
+# installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to dateutil.tz.gettz()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the
+# "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to alembic/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "version_path_separator" below.
+# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
+
+# version path separator; As mentioned above, this is the character used to split
+# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
+# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
+# Valid values for version_path_separator are:
+#
+# version_path_separator = :
+# version_path_separator = ;
+# version_path_separator = space
+version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+sqlalchemy.url = driver://user:pass@localhost/dbname
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

alembic/README

@@ -0,0 +1 @@
+Generic single-database configuration.

alembic/env.py

@@ -0,0 +1,86 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+from app.config import settings
+from app.models import Base
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+config.set_main_option(
+    "sqlalchemy.url",
+    f"postgresql+psycopg2://{settings.POSTGRES_USER}:{settings.POSTGRES_PASSWORD}@{settings.POSTGRES_HOSTNAME}:{settings.DATABASE_PORT}/{settings.POSTGRES_DB}"
+)
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = Base.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, target_metadata=target_metadata
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

alembic/script.py.mako

@@ -0,0 +1,24 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}

alembic/versions/64174712dd01_migrate.py

@@ -0,0 +1,44 @@
+"""migrate
+
+Revision ID: 64174712dd01
+Revises: d4b392539c2c
+Create Date: 2023-12-08 04:14:27.348117
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = '64174712dd01'
+down_revision = 'd4b392539c2c'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('doctors',
+    sa.Column('id', postgresql.UUID(as_uuid=True), nullable=False),
+    sa.Column('name', sa.String(), nullable=False),
+    sa.Column('price', sa.String(), nullable=False),
+    sa.Column('rating', sa.String(), nullable=False),
+    sa.Column('role', sa.String(), server_default='Hewan', nullable=False),
+    sa.Column('role_detail', sa.String(), nullable=False),
+    sa.Column('day', sa.String(), nullable=True),
+    sa.Column('time', sa.String(), nullable=False),
+    sa.Column('location', sa.String(), nullable=False),
+    sa.Column('university', sa.String(), nullable=False),
+    sa.Column('yearofexperience', sa.String(), nullable=False),
+    sa.Column('created_at', sa.TIMESTAMP(timezone=True), server_default=sa.text('now()'), nullable=False),
+    sa.Column('updated_at', sa.TIMESTAMP(timezone=True), server_default=sa.text('now()'), nullable=False),
+    sa.PrimaryKeyConstraint('id'),
+    sa.UniqueConstraint('name')
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('doctors')
+    # ### end Alembic commands ###

alembic/versions/af0bc5bbaf5d_initial_migration.py

@@ -0,0 +1,49 @@
+"""Initial migration
+
+Revision ID: af0bc5bbaf5d
+Revises: 64174712dd01
+Create Date: 2024-07-18 03:46:35.639043
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = 'af0bc5bbaf5d'
+down_revision = '64174712dd01'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('pets',
+    sa.Column('id', postgresql.UUID(as_uuid=True), nullable=False),
+    sa.Column('name', sa.String(), nullable=False),
+    sa.Column('age', sa.String(), nullable=False),
+    sa.Column('gender', sa.Enum('Jantan', 'Betina', name='gender'), nullable=False),
+    sa.Column('created_at', sa.TIMESTAMP(timezone=True), server_default=sa.text('now()'), nullable=False),
+    sa.Column('updated_at', sa.TIMESTAMP(timezone=True), server_default=sa.text('now()'), nullable=False),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_table('users',
+    sa.Column('id', postgresql.UUID(as_uuid=True), nullable=False),
+    sa.Column('name', sa.String(), nullable=False),
+    sa.Column('email', sa.String(), nullable=False),
+    sa.Column('password', sa.String(), nullable=False),
+    sa.Column('verified', sa.Boolean(), server_default='False', nullable=False),
+    sa.Column('role', sa.String(), server_default='user', nullable=False),
+    sa.Column('created_at', sa.TIMESTAMP(timezone=True), server_default=sa.text('now()'), nullable=False),
+    sa.Column('updated_at', sa.TIMESTAMP(timezone=True), server_default=sa.text('now()'), nullable=False),
+    sa.PrimaryKeyConstraint('id'),
+    sa.UniqueConstraint('email')
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('users')
+    op.drop_table('pets')
+    # ### end Alembic commands ###

alembic/versions/d4b392539c2c_create_users_table.py

@@ -0,0 +1,27 @@
+"""create users table
+
+Revision ID: d4b392539c2c
+Create Date: 2023-12-06 06:52:25.020699
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = 'd4b392539c2c'
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###

app.py

@@ -0,0 +1,71 @@
+from fastapi import FastAPI
+from app.config import settings
+from fastapi.responses import RedirectResponse
+from fastapi.middleware.cors import CORSMiddleware
+from app.routers import user, auth, upload, pet, disease_detection, doctor
+
+app = FastAPI()
+
+origins = [
+    settings.CLIENT_ORIGIN,
+]
+
+app.add_middleware(
+    middleware_class = CORSMiddleware,
+    allow_origins = ["*"],
+    allow_methods = ["*"],
+    allow_headers = ["*"],
+    allow_credentials = True
+)
+
+# Auth Routes Group
+app.include_router(
+    tags = ['Auth'],
+    router = auth.router,
+    prefix = '/api/auth'
+)
+
+# User Routes Group
+app.include_router(
+    tags = ['Users'],
+    router = user.router,
+    prefix = '/api/users'
+)
+
+# Upload Routes Group
+app.include_router(
+    tags = ['Upload'],
+    router = upload.router,
+    prefix = '/api/upload'
+)
+
+# Pet Routes Group
+app.include_router(
+    tags = ['Pets'],
+    router = pet.router,
+    prefix = '/api/pets'
+)
+
+# Doctor Routes Group
+app.include_router(
+    tags = ['Doctors'],
+    router = doctor.router,
+    prefix = '/api/doctors'
+)
+
+# Disease Detection Routes Group
+app.include_router(
+    tags = ['Disease Detection'],
+    router = disease_detection.router,
+    prefix = '/api/disease_detection'
+)
+
+# Main Routes Group
+@app.get('/api/checker', tags = ['Main'])
+def checker():
+    return {'message': 'Hello Docpet!'}
+
+@app.get("/", tags = ['Main'])
+def root():
+    return RedirectResponse(url="/docs")
+    

app/config.py

@@ -0,0 +1,22 @@
+from pydantic import BaseSettings, EmailStr
+
+class Settings(BaseSettings):
+    DATABASE_PORT: int
+    POSTGRES_PASSWORD: str
+    POSTGRES_USER: str
+    POSTGRES_DB: str
+    POSTGRES_HOST: str
+    POSTGRES_HOSTNAME: str
+
+    JWT_PUBLIC_KEY: str
+    JWT_PRIVATE_KEY: str
+    REFRESH_TOKEN_EXPIRES_IN: int
+    ACCESS_TOKEN_EXPIRES_IN: int
+    JWT_ALGORITHM: str
+
+    CLIENT_ORIGIN: str
+
+    class Config:
+        env_file = './.env'
+
+settings = Settings()

app/database.py

@@ -0,0 +1,21 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from .config import settings
+
+SQLALCHEMY_DATABASE_URL = f"postgresql://{settings.POSTGRES_USER}:{settings.POSTGRES_PASSWORD}@{settings.POSTGRES_HOSTNAME}:{settings.DATABASE_PORT}/{settings.POSTGRES_DB}"
+
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL
+)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

app/gcs.py

@@ -0,0 +1,19 @@
+from google.cloud import storage
+
+# def create_gcs_client():
+#     return storage.Client.from_service_account_json(
+#         json_credentials_path = 'docpet-project-ch2-ps068-a53f10c5c713.json'
+#     )
+
+def upload_blob(bucket_name, source_file_name, destination_blob_name):
+    print("iwan fals: 'dar der dor suara senapan...'")
+    # """Uploads a file to the bucket."""
+    # storage_client = create_gcs_client()
+    # bucket = storage_client.bucket(bucket_name)
+    # blob = bucket.blob(destination_blob_name)
+
+    # blob.upload_from_filename(source_file_name)
+
+    # print('File {} uploaded to {}.'.format(
+    #     source_file_name,
+    #     destination_blob_name))

app/main.py

@@ -0,0 +1,71 @@
+from fastapi import FastAPI
+from app.config import settings
+from fastapi.responses import RedirectResponse
+from fastapi.middleware.cors import CORSMiddleware
+from app.routers import user, auth, upload, pet, disease_detection, doctor
+
+app = FastAPI()
+
+origins = [
+    settings.CLIENT_ORIGIN,
+]
+
+app.add_middleware(
+    middleware_class = CORSMiddleware,
+    allow_origins = ["*"],
+    allow_methods = ["*"],
+    allow_headers = ["*"],
+    allow_credentials = True
+)
+
+# Auth Routes Group
+app.include_router(
+    tags = ['Auth'],
+    router = auth.router,
+    prefix = '/api/auth'
+)
+
+# User Routes Group
+app.include_router(
+    tags = ['Users'],
+    router = user.router,
+    prefix = '/api/users'
+)
+
+# Upload Routes Group
+app.include_router(
+    tags = ['Upload'],
+    router = upload.router,
+    prefix = '/api/upload'
+)
+
+# Pet Routes Group
+app.include_router(
+    tags = ['Pets'],
+    router = pet.router,
+    prefix = '/api/pets'
+)
+
+# Doctor Routes Group
+app.include_router(
+    tags = ['Doctors'],
+    router = doctor.router,
+    prefix = '/api/doctors'
+)
+
+# Disease Detection Routes Group
+app.include_router(
+    tags = ['Disease Detection'],
+    router = disease_detection.router,
+    prefix = '/api/disease_detection'
+)
+
+# Main Routes Group
+@app.get('/api/checker', tags = ['Main'])
+def checker():
+    return {'message': 'Hello Docpet!'}
+
+@app.get("/", tags = ['Main'])
+def root():
+    return RedirectResponse(url="/docs")
+    

app/models.py

@@ -0,0 +1,50 @@
+import uuid # uuid is used to generate a random unique id for each user
+from .database import Base
+from sqlalchemy import TIMESTAMP, Column, String, Boolean, text, Enum
+from sqlalchemy.dialects.postgresql import UUID
+
+# User model
+class User(Base):
+    __tablename__ = 'users'
+    id = Column(UUID(as_uuid=True), primary_key=True, nullable=False,
+                default=uuid.uuid4)
+    name = Column(String,  nullable=False)
+    email = Column(String, unique=True, nullable=False)
+    password = Column(String, nullable=False)
+    verified = Column(Boolean, nullable=False, server_default='False')
+    role = Column(String, server_default='user', nullable=False)
+    created_at = Column(TIMESTAMP(timezone=True),
+                        nullable=False, server_default=text("now()"))
+    updated_at = Column(TIMESTAMP(timezone=True),
+                        nullable=False, server_default=text("now()"))
+
+class Pet(Base):
+    __tablename__ = 'pets'
+    id = Column(UUID(as_uuid=True), primary_key=True, nullable=False,
+                default=uuid.uuid4)
+    name = Column(String, nullable=False)
+    age = Column(String, nullable=False)
+    gender = Column(Enum('Jantan', 'Betina', name='gender'), nullable=False)
+    created_at = Column(TIMESTAMP(timezone=True),
+                        nullable=False, server_default=text("now()"))
+    updated_at = Column(TIMESTAMP(timezone=True),
+                        nullable=False, server_default=text("now()"))
+    
+class Doctor(Base):
+    __tablename__ = 'doctors'
+    id = Column(UUID(as_uuid=True), primary_key=True, nullable=False,
+                default=uuid.uuid4)
+    name = Column(String, unique=True, nullable=False)
+    price = Column(String, nullable=False)
+    rating = Column(String, nullable=False)
+    role = Column(String, server_default='Hewan', nullable=False)
+    role_detail = Column(String, nullable=False)
+    day = Column(String, nullable=True)
+    time = Column(String, nullable=False)
+    location = Column(String, nullable=False)
+    university = Column(String, nullable=False)
+    yearofexperience = Column(String, nullable=False)
+    created_at = Column(TIMESTAMP(timezone=True),
+                        nullable=False, server_default=text("now()"))
+    updated_at = Column(TIMESTAMP(timezone=True),
+                        nullable=False, server_default=text("now()"))

app/oauth2.py

@@ -0,0 +1,65 @@
+import base64
+from typing import List
+from fastapi import Depends, HTTPException, status
+from fastapi_jwt_auth import AuthJWT
+from pydantic import BaseModel
+
+from . import models
+from .database import get_db
+from sqlalchemy.orm import Session
+from .config import settings
+
+
+class Settings(BaseModel):
+    authjwt_algorithm: str = settings.JWT_ALGORITHM
+    authjwt_decode_algorithms: List[str] = [settings.JWT_ALGORITHM]
+    authjwt_token_location: set = {'cookies', 'headers'}
+    authjwt_access_cookie_key: str = 'access_token'
+    authjwt_refresh_cookie_key: str = 'refresh_token'
+    authjwt_cookie_csrf_protect: bool = False
+    authjwt_public_key: str = base64.b64decode(
+        settings.JWT_PUBLIC_KEY).decode('utf-8')
+    authjwt_private_key: str = base64.b64decode(
+        settings.JWT_PRIVATE_KEY).decode('utf-8')
+
+
+@AuthJWT.load_config
+def get_config():
+    return Settings()
+
+
+class NotVerified(Exception):
+    pass
+
+
+class UserNotFound(Exception):
+    pass
+
+
+def require_user(db: Session = Depends(get_db), Authorize: AuthJWT = Depends()):
+    try:
+        Authorize.jwt_required()
+        user_id = Authorize.get_jwt_subject()
+        user = db.query(models.User).filter(models.User.id == user_id).first()
+
+        if not user:
+            raise UserNotFound('User no longer exist')
+
+        if not user.verified:
+            raise NotVerified('You are not verified')
+
+    except Exception as e:
+        error = e.__class__.__name__
+        print(error)
+        if error == 'MissingTokenError':
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED, detail='You are not logged in')
+        if error == 'UserNotFound':
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED, detail='User no longer exist')
+        if error == 'NotVerified':
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED, detail='Please verify your account')
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail='Token is invalid or has expired')
+    return user_id

app/routers/auth.py

@@ -0,0 +1,116 @@
+from datetime import timedelta
+from fastapi import APIRouter, Request, Response, status, Depends, HTTPException
+from pydantic import EmailStr
+
+from app import oauth2
+from .. import schemas, models, utils
+from sqlalchemy.orm import Session
+from ..database import get_db
+from app.oauth2 import AuthJWT
+from ..config import settings
+
+router = APIRouter()
+ACCESS_TOKEN_EXPIRES_IN = settings.ACCESS_TOKEN_EXPIRES_IN
+REFRESH_TOKEN_EXPIRES_IN = settings.REFRESH_TOKEN_EXPIRES_IN
+
+@router.post('/register', status_code=status.HTTP_201_CREATED, response_model=schemas.UserResponse)
+async def create_user(payload: schemas.CreateUserSchema, db: Session = Depends(get_db)):
+    # Check if user already exist
+    user = db.query(models.User).filter(
+        models.User.email == EmailStr(payload.email.lower())).first()
+    if user:
+        raise HTTPException(status_code=status.HTTP_409_CONFLICT,
+                            detail='Account already exist')
+    # Compare password and passwordConfirm
+    if payload.password != payload.passwordConfirm:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail='Passwords do not match')
+    #  Hash the password
+    payload.password = utils.hash_password(payload.password)
+    del payload.passwordConfirm
+    payload.role = 'user'
+    payload.verified = True
+    payload.email = EmailStr(payload.email.lower())
+    new_user = models.User(**payload.dict())
+    db.add(new_user)
+    db.commit()
+    db.refresh(new_user)
+    return new_user
+
+
+@router.post('/login')
+def login(payload: schemas.LoginUserSchema, response: Response, db: Session = Depends(get_db), Authorize: AuthJWT = Depends()):
+    # Check if the user exist
+    user = db.query(models.User).filter(
+        models.User.email == EmailStr(payload.email.lower())).first()
+    if not user:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
+                            detail='Incorrect Email or Password')
+
+    # Check if user verified his email
+    if not user.verified:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
+                            detail='Please verify your email address')
+
+    # Check if the password is valid
+    if not utils.verify_password(payload.password, user.password):
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
+                            detail='Incorrect Email or Password')
+
+    # Create access token
+    access_token = Authorize.create_access_token(
+        subject=str(user.id), expires_time=timedelta(minutes=ACCESS_TOKEN_EXPIRES_IN))
+
+    # Create refresh token
+    refresh_token = Authorize.create_refresh_token(
+        subject=str(user.id), expires_time=timedelta(minutes=REFRESH_TOKEN_EXPIRES_IN))
+
+    # Store refresh and access tokens in cookie
+    response.set_cookie('access_token', access_token, ACCESS_TOKEN_EXPIRES_IN * 60,
+                        ACCESS_TOKEN_EXPIRES_IN * 60, '/', None, False, True, 'lax')
+    response.set_cookie('refresh_token', refresh_token,
+                        REFRESH_TOKEN_EXPIRES_IN * 60, REFRESH_TOKEN_EXPIRES_IN * 60, '/', None, False, True, 'lax')
+    response.set_cookie('logged_in', 'True', ACCESS_TOKEN_EXPIRES_IN * 60,
+                        ACCESS_TOKEN_EXPIRES_IN * 60, '/', None, False, False, 'lax')
+
+    # Send both access
+    return {'status': 'success', 'access_token': access_token}
+
+
+@router.get('/refresh')
+def refresh_token(response: Response, request: Request, Authorize: AuthJWT = Depends(), db: Session = Depends(get_db)):
+    try:
+        print(Authorize._refresh_cookie_key)
+        Authorize.jwt_refresh_token_required()
+
+        user_id = Authorize.get_jwt_subject()
+        if not user_id:
+            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
+                                detail='Could not refresh access token')
+        user = db.query(models.User).filter(models.User.id == user_id).first()
+        if not user:
+            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
+                                detail='The user belonging to this token no logger exist')
+        access_token = Authorize.create_access_token(
+            subject=str(user.id), expires_time=timedelta(minutes=ACCESS_TOKEN_EXPIRES_IN))
+    except Exception as e:
+        error = e.__class__.__name__
+        if error == 'MissingTokenError':
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST, detail='Please provide refresh token')
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=error)
+
+    response.set_cookie('access_token', access_token, ACCESS_TOKEN_EXPIRES_IN * 60,
+                        ACCESS_TOKEN_EXPIRES_IN * 60, '/', None, False, True, 'lax')
+    response.set_cookie('logged_in', 'True', ACCESS_TOKEN_EXPIRES_IN * 60,
+                        ACCESS_TOKEN_EXPIRES_IN * 60, '/', None, False, False, 'lax')
+    return {'access_token': access_token}
+
+
+@router.get('/logout', status_code=status.HTTP_200_OK)
+def logout(response: Response, Authorize: AuthJWT = Depends(), user_id: str = Depends(oauth2.require_user)):
+    Authorize.unset_jwt_cookies()
+    response.set_cookie('logged_in', '', -1)
+
+    return {'status': 'success'}

app/routers/disease_detection.py

@@ -0,0 +1,90 @@
+import os
+import time
+import string
+import secrets
+from http import HTTPStatus
+from app.gcs import upload_blob
+from app.oauth2 import require_user
+from app.utils import image_prediction
+from fastapi.responses import JSONResponse
+from fastapi import UploadFile, File, Depends, APIRouter
+
+router = APIRouter()
+
+@router.post("/")
+async def disease_detection(
+    file: UploadFile = File(...), 
+    # _: str = Depends(require_user)
+) -> JSONResponse:
+    try:
+        file.file.seek(0, 2)
+        file_size = file.file.tell()
+
+        await file.seek(0)
+
+        # 1 kb = 1024 bytes
+        # 1 mb = 1024 kb
+        if file_size > 10 * 1024 * 1024:
+            # if more than 10 mb
+            return JSONResponse(
+                content = {
+                    'message': 'file too large (MAX: 10 MB)',
+                    'status_code': HTTPStatus.BAD_REQUEST,
+                    'data': None
+                },
+                status_code = HTTPStatus.BAD_REQUEST
+            )
+
+        content_type = file.content_type
+        if content_type not in ["image/jpeg", "image/jpg", "image/png"]:
+            return JSONResponse(
+                content = {
+                    'message': 'invalid file type',
+                    'status_code': HTTPStatus.BAD_REQUEST,
+                    'data': None
+                },
+                status_code = HTTPStatus.BAD_REQUEST
+            )
+
+        file_location = f"temp/{file.filename}"
+        os.makedirs(os.path.dirname(file_location), exist_ok=True)
+
+        with open(file_location, "wb+") as file_object:
+            file_object.write(file.file.read())
+
+        # Prediction Result
+        predict_result = image_prediction(file_location)
+
+        timestamp = str(int(time.time()))
+        random_string = ''.join(
+            secrets.choice(string.ascii_letters + string.digits) for _ in range(64)
+        )
+
+        # Upload to Google Cloud Storage
+        upload_blob(
+            bucket_name = "docpet-dev-test",
+            source_file_name = file_location, 
+            destination_blob_name = f"{timestamp}-{random_string}.jpeg"
+        )
+
+        os.remove(file_location)
+
+        return JSONResponse(
+            content = {
+                'message': 'prediction success',
+                'status_code': HTTPStatus.OK,
+                'data': predict_result
+            },
+            status_code = HTTPStatus.OK
+        )
+
+    except Exception as e:
+        print(e)
+        return JSONResponse(
+            content = {
+                'message': 'Internal Server Error',
+                'status_code': HTTPStatus.INTERNAL_SERVER_ERROR,
+                'data': None
+            },
+            status_code = HTTPStatus.INTERNAL_SERVER_ERROR
+        )

app/routers/doctor.py

@@ -0,0 +1,66 @@
+import uuid
+from fastapi import APIRouter, HTTPException
+from app.schemas import CreateDoctorSchema, UpdateDoctorSchema, DoctorResponse
+from app.models import Doctor
+from app.database import SessionLocal
+
+router = APIRouter()
+
+@router.get("/")
+async def get_doctors():
+    db = SessionLocal()
+    try:
+        doctors = db.query(Doctor).all()
+        return [{"id": Doctor.id, "name": Doctor.name, "role_detail": Doctor.role_detail, "rating": Doctor.rating , "price": Doctor.price, "university": Doctor.university, "yearofexperience": Doctor.yearofexperience} for Doctor in doctors]
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        db.close()
+
+@router.get("/{doctor_id}")
+async def get_doctor(doctor_id: uuid.UUID):
+    db = SessionLocal()
+    try:
+        doctor = db.query(Doctor).filter(Doctor.id == doctor_id).first()
+        if not doctor:
+            raise HTTPException(status_code=404, detail="Doctor not found")
+        return doctor
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        db.close()        
+
+@router.post("/")
+async def create_doctor(doctor: CreateDoctorSchema):
+    db = SessionLocal()
+    try:
+        new_doctor = Doctor(**doctor.dict())
+        db.add(new_doctor)
+        db.commit()
+        db.refresh(new_doctor)
+        return {"message": "Doctor created successfully", "doctor": new_doctor.__dict__}
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        db.close()
+
+@router.put("/{doctor_id}")
+async def update_doctor(doctor_id: uuid.UUID, doctor: UpdateDoctorSchema):
+    db = SessionLocal()
+    try:
+        existing_doctor = db.query(Doctor).filter(Doctor.id == doctor_id).first()
+        if not existing_doctor:
+            raise HTTPException(status_code=404, detail="Doctor not found")
+        for attr, value in doctor.dict().items():
+            setattr(existing_doctor, attr, value)
+        db.commit()
+        return {"message": "Doctor updated successfully", "doctor": existing_doctor.__dict__}
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        db.close()
+        

app/routers/pet.py

@@ -0,0 +1,50 @@
+import uuid
+from fastapi import APIRouter, HTTPException
+from app.schemas import CreatePetSchema, UpdatePetSchema
+from app.models import Pet
+from app.database import SessionLocal
+
+router = APIRouter()
+
+@router.get("/")
+async def get_pets():
+    db = SessionLocal()
+    try:
+        pets = db.query(Pet).all()
+        return [{"id": pet.id, "name": pet.name, "age": pet.age} for pet in pets]
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        db.close()
+
+@router.post("/")
+async def create_pet(pet: CreatePetSchema):
+    db = SessionLocal()
+    try:
+        new_pet = Pet(**pet.dict())
+        db.add(new_pet)
+        db.commit()
+        return {"id": new_pet.id, "name": new_pet.name, "age": new_pet.age}
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        db.close()
+
+@router.put("/{pet_id}", response_model=UpdatePetSchema)
+async def update_pet(pet_id: uuid.UUID, pet: UpdatePetSchema):
+    db = SessionLocal()
+    try:
+        existing_pet = db.query(Pet).filter(Pet.id == pet_id).first()
+        if not existing_pet:
+            raise HTTPException(status_code=404, detail="Pet not found")
+        for attr, value in pet.dict().items():
+            setattr(existing_pet, attr, value)
+        db.commit()
+        return {"id": existing_pet.id, "name": existing_pet.name, "age": existing_pet.age, "gender": existing_pet.gender}
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=400, detail=str(e))
+    finally:
+        db.close()

app/routers/upload.py

@@ -0,0 +1,17 @@
+from fastapi import UploadFile, File, APIRouter
+from app.gcs import upload_blob
+import os
+
+router = APIRouter()
+
+@router.post("/")
+async def upload_file(file: UploadFile = File(...)):
+    try:
+        file_location = f"temp/{file.filename}"
+        os.makedirs(os.path.dirname(file_location), exist_ok=True)
+        with open(file_location, "wb+") as file_object:
+            file_object.write(file.file.read())
+        upload_blob("docpet-dev-test", file_location, file.filename)
+        return {"success": True, "filename": file.filename, "message": "File uploaded successfully"}
+    except Exception as e:
+        return {"success": False, "message": str(e)}

app/routers/user.py

@@ -0,0 +1,12 @@
+from fastapi import APIRouter, Depends
+from ..database import get_db
+from sqlalchemy.orm import Session
+from .. import models, schemas, oauth2
+
+router = APIRouter()
+
+
+@router.get('/me', response_model=schemas.UserResponse)
+def get_me(db: Session = Depends(get_db), user_id: str = Depends(oauth2.require_user)):
+    user = db.query(models.User).filter(models.User.id == user_id).first()
+    return user

app/schemas.py

@@ -0,0 +1,67 @@
+from datetime import datetime
+import uuid
+from pydantic import BaseModel, EmailStr, constr, Field
+from enum import Enum
+
+class UserBaseSchema(BaseModel):
+    name: str
+    email: EmailStr
+
+    class Config:
+        orm_mode = True
+
+
+class CreateUserSchema(UserBaseSchema):
+    password: constr(min_length=8)
+    passwordConfirm: str
+    role: str = 'user'
+    verified: bool = False
+
+
+class LoginUserSchema(BaseModel):
+    email: EmailStr
+    password: constr(min_length=8)
+
+
+class UserResponse(UserBaseSchema):
+    id: uuid.UUID
+    created_at: datetime
+    updated_at: datetime
+
+class GenderEnum(str, Enum):
+    Jantan = 'Jantan'
+    Betina = 'Betina'
+
+class PetBaseSchema(BaseModel):
+    name: constr(max_length=20) = Field(..., description="Pet's name")
+    gender: GenderEnum = Field(..., description="Pet's gender")
+    age: str = Field(..., description="Pet's age")
+
+class CreatePetSchema(PetBaseSchema):
+    pass
+
+class UpdatePetSchema(PetBaseSchema):
+    pass
+
+class DoctorBaseSchema(BaseModel):
+    name: constr(max_length=20) = Field(..., description="Doctor's name")
+    price: str = Field(..., description="Doctor's price")
+    rating: str = Field(..., description="Doctor's rating")
+    role: str = Field(..., description="Doctor's role")
+    role_detail: str = Field(..., description="Doctor's detail")
+    day: str = Field(..., description="Doctor's day")
+    time: str = Field(..., description="Doctor's time")
+    location: str = Field(..., description="Doctor's location")
+    university: str = Field(..., description="Doctor's university")
+    yearofexperience: str = Field(..., description="Doctor's year of experience")
+
+class CreateDoctorSchema(DoctorBaseSchema):
+    pass
+
+class UpdateDoctorSchema(DoctorBaseSchema):
+    pass
+
+class DoctorResponse(DoctorBaseSchema):
+    id: uuid.UUID
+    created_at: datetime
+    updated_at: datetime

app/utils.py

@@ -0,0 +1,34 @@
+import json
+import numpy as np
+from passlib.context import CryptContext
+from tensorflow.keras.models import load_model
+from tensorflow.keras.utils import load_img, img_to_array
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def hash_password(password: str):
+    return pwd_context.hash(password)
+
+def verify_password(password: str, hashed_password: str):
+    return pwd_context.verify(password, hashed_password)
+
+def image_prediction(image_location: str) -> dict:
+    labels = json.load(open("./ml_models/labels.json")) \
+        .get("disease_labels")
+
+    model = load_model('./ml_models/model.h5')
+
+    image = load_img(image_location, target_size = (224, 224))
+
+    x = np.expand_dims(a = img_to_array(image), axis = 0)
+    
+    images = np.vstack(tup = [x])
+    classes = model.predict(x = images, batch_size = 32)
+
+    for idx_predict, class_value in enumerate(classes[0]):
+        if class_value == 1:
+            label = labels[idx_predict]
+            break
+    else: label = None
+
+    return label

deployment/development.dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.9-bullseye
+
+LABEL team="cloud-computing-team"
+
+# Write Byte Code and Buffered
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+
+# Set Working Directory
+WORKDIR /etc/docpet_backend_service
+
+# Upgrade PIP
+RUN python3 -m pip install --upgrade pip
+
+# Install the Requirements
+COPY requirements/linux.requirements.txt \
+    /etc/docpet_backend_service/
+
+RUN pip3 install -r linux.requirements.txt
+
+COPY . /etc/docpet_backend_service/
+
+EXPOSE 8000
+
+CMD [ "/bin/bash", "-c", "alembic upgrade head && uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload" ]

deployment/production.dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.9-bullseye
+
+LABEL team="cloud-computing-team"
+
+# Write Byte Code and Buffered
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+
+# Set Working Directory
+WORKDIR /etc/docpet_backend_service
+
+# Upgrade PIP
+RUN python3 -m pip install --upgrade pip
+
+# Install the Requirements
+COPY requirements/linux.requirements.txt \
+    /etc/docpet_backend_service/
+
+RUN pip3 install -r linux.requirements.txt
+
+COPY . /etc/docpet_backend_service/
+
+EXPOSE 80
+
+CMD [ "/bin/bash", "-c", "alembic upgrade head && uvicorn app.main:app --host 0.0.0.0 --port 80 --workers 10" ]

docker-compose.yml

@@ -0,0 +1,15 @@
+version: '3.3'
+services:
+  postgres:
+    image: postgres
+    container_name: postgres
+    ports:
+      - '6500:5432'
+    restart: always
+    env_file:
+      - ./.env
+    volumes:
+      - postgres-db:/var/lib/postgresql/data
+
+volumes:
+  postgres-db:

main.tf

@@ -0,0 +1,19 @@
+terraform {
+    required_version = ">= 1.0"
+
+    required_providers {
+        google = {
+            source  = "hashicorp/google"
+            version = "5.6.0"
+        }
+    }
+
+    backend "gcs" {
+        bucket  = "docpet-terraform-state-store"
+    }
+}
+
+provider "google" {
+    project = var.project_id
+    region  = var.region
+}

ml_models/labels.json

@@ -0,0 +1,31 @@
+{
+    "disease_labels": [
+        {
+            "name": "Mata Katarak",
+            "symptom": "Katarak dapat menunjukkan gejala seperti perubahan warna mata yang keruh atau kabur, matanya terlihat kebiruan atau putih, kehilangan kemampuan untuk melihat dengan jelas, hingga penurunan aktivitas atau ketidakmampuan untuk menangkap pergerakan dengan cepat. Hewan mungkin terlihat lebih tidak aktif atau cenderung menabrak benda-benda di sekitarnya. Gejala ini dapat berkembang secara perlahan dan bertahap. Penting untuk segera konsultasikan ke dokter hewan jika ada indikasi katarak, karena pengobatan dini dapat membantu mencegah kemungkinan penurunan penglihatan yang lebih lanjut.",
+            "treatment": "Katarak dapat diobati dengan pembedahan untuk mengangkat lensa mata yang keruh dan menggantinya dengan lensa buatan. Setelah operasi, penggunaan tetes mata antibiotik dan antiinflamasi diresepkan untuk mencegah infeksi dan mengurangi peradangan. Terapi medis atau perubahan pola makan juga dapat membantu jika katarak belum parah namun mulai mengganggu penglihatan. Penting untuk pemantauan berkala oleh dokter hewan untuk memastikan pemulihan yang optimal.",
+            "information": "Katarak pada hewan peliharaan dapat dipicu oleh faktor genetik, usia, cedera, atau kondisi medis tertentu seperti diabetes. Gejalanya bisa berkembang secara perlahan dan terkadang sulit untuk terdeteksi pada awalnya. Pemantauan secara rutin terhadap mata peliharaan serta kunjungan teratur ke dokter hewan dapat membantu mendeteksi katarak lebih awal dan mengurangi risiko penurunan penglihatan yang signifikan. Makanan khusus untuk kesehatan mata dan suplemen tertentu juga dapat direkomendasikan untuk membantu menjaga kesehatan mata hewan peliharaan."
+        },
+  
+        {
+            "name": "Mata Glaukoma",
+            "symptom": "Glaukoma ditandai dengan gejala seperti pupil yang melebar, mata yang kemerahan, peningkatan tekanan bola mata, pembengkakan mata, dan kadang-kadang terlihat benjolan pada mata. Hewan peliharaan mungkin mengalami sakit atau tidak nyaman, dapat terjadi perubahan dalam perilaku mereka seperti menjadi lebih sensitif terhadap cahaya atau menggosok-gosokkan matanya secara berlebihan. Penglihatan hewan juga bisa terpengaruh, yang dapat dilihat dari perilaku mereka yang lebih waspada atau kesulitan melihat dengan jelas. Deteksi dini dan penanganan oleh dokter hewan penting untuk mencegah kerusakan permanen pada mata.",
+            "treatment": "Pengobatan glaukoma bergantung pada tingkat keparahan dan penyebabnya. Dokter hewan dapat meresepkan obat tetes mata untuk mengurangi tekanan bola mata. Dalam beberapa kasus, prosedur bedah seperti iridektomi (pembuatan lubang kecil pada iris) atau enukleasi (pengangkatan mata) mungkin diperlukan jika glaukoma sudah parah dan tidak merespons pengobatan medis. Perawatan tambahan seperti terapi penghilang rasa sakit juga sering direkomendasikan untuk mengurangi ketidaknyamanan hewan peliharaan. Penting untuk segera berkonsultasi dengan dokter hewan untuk penanganan yang tepat sesuai dengan kondisi individu hewan.",
+            "information": "Glaukoma pada hewan terjadi ketika tekanan di dalam bola mata meningkat secara signifikan, menyebabkan kerusakan pada saraf mata. Ini bisa bersifat primer (idiopatik) atau sekunder, terkait dengan cedera, infeksi, atau masalah mata lainnya. Glaukoma seringkali merupakan kondisi darurat karena dapat menyebabkan kebutaan dalam waktu singkat jika tidak ditangani dengan cepat. Pemantauan teratur tekanan bola mata, penggunaan obat tetes mata untuk mengontrol tekanan, serta pemeriksaan rutin oleh dokter hewan sangat penting untuk mengelola kondisi ini dan mencegah kerusakan mata yang parah."
+        },
+
+        {
+            "name": "Mata Konjungtivitis",
+            "symptom": "Konjungtivitis ditandai oleh mata yang merah, bengkak, dan mungkin mengeluarkan lebih banyak air mata atau sekresi yang tidak normal, seperti lendir atau nanah. Hewan tersebut mungkin merasa tidak nyaman, menunjukkan tanda-tanda gatal atau sensasi terbakar di sekitar mata, yang bisa menyebabkan mereka menggaruk atau menggosok area tersebut. Kasus yang lebih parah dapat menyebabkan kelopak mata menutup atau menempel bersama karena pembengkakan atau sekresi. Sensitivitas terhadap cahaya juga bisa menjadi gejala. Penting untuk membawa hewan peliharaan ke dokter hewan untuk diagnosis yang tepat dan perawatan yang sesuai, karena konjungtivitis bisa disebabkan oleh berbagai faktor seperti infeksi bakteri, virus, alergi, atau iritasi oleh benda asing. Dokter hewan akan dapat menentukan penyebabnya dan meresepkan pengobatan yang sesuai untuk mengatasi kondisi mata tersebut.",
+            "treatment": "Pengobatan untuk konjungtivitis pada umumnya melibatkan pendekatan yang spesifik terhadap penyebabnya. Dokter hewan sering meresepkan tetes mata atau salep mata yang mengandung antibiotik, antiviral, atau bahan yang sesuai dengan penyebab infeksi mata tersebut. Selain itu, pembersihan mata secara teratur dengan larutan khusus atau air steril juga direkomendasikan untuk menghilangkan sekresi dan bahan iritan dari mata. Terapi kompres hangat dengan lap bersih dapat membantu mengurangi pembengkakan serta meningkatkan kenyamanan hewan. Pengobatan pendukung seperti antihistamin atau perubahan lingkungan juga mungkin direkomendasikan jika konjungtivitis disebabkan oleh alergi. Perawatan tambahan seperti antibiotik atau prosedur medis lainnya bisa diperlukan tergantung pada keparahan infeksi atau komplikasi yang mungkin terjadi. Penting untuk mengikuti instruksi dokter hewan dengan teliti dan tidak menggunakan obat-obatan tanpa persetujuan dokter, serta memantau perkembangan gejala. Jika gejalanya tidak membaik atau memburuk, segera konsultasikan kembali dengan dokter hewan untuk penanganan lebih lanjut.",
+            "information": "Konjungtivitis adalah kondisi di mana mata menjadi merah, bengkak, dan sering kali mengeluarkan cairan yang berlebihan, seperti air mata, lendir, atau nanah. Gejalanya juga dapat mencakup rasa gatal atau terbakar di sekitar mata, kelopak mata yang mungkin sulit untuk dibuka, serta sensitivitas terhadap cahaya. Penyebabnya bisa bervariasi, mulai dari infeksi bakteri atau virus seperti Chlamydia atau herpes, reaksi alergi terhadap debu atau serbuk sari, hingga iritasi karena benda asing yang masuk ke mata. Pengobatan tergantung pada penyebabnya; untuk infeksi, dokter hewan mungkin meresepkan tetes atau salep mata dengan antibiotik atau antiviral. Sementara itu, dalam kasus alergi, manajemen lingkungan dan terapi antihistamin bisa direkomendasikan. Membersihkan mata secara teratur dan menjaga kebersihan lingkungan hewan peliharaan juga penting. Penting untuk mendapatkan diagnosis yang tepat dari dokter hewan dan mengikuti perawatan yang diresepkan dengan cermat untuk memastikan pemulihan yang optimal bagi hewan peliharaan Anda."
+        },
+    
+        {
+            "name": "Mata Normal",
+            "symptom": "Mata normal biasanya memiliki pupil yang seragam dan responsif terhadap cahaya dengan baik. Kornea (bagian jernih di depan mata) bersih tanpa kekeruhan, memungkinkan cahaya masuk dengan baik. Iris (bagian berwarna di dalam mata) tampak normal, tidak ada perubahan warna atau bengkak yang mencolok. Sklera (bagian putih mata) tidak merah atau terlalu berwarna, menunjukkan kesehatan yang baik. Mata juga tidak mengalami air mata berlebihan atau keluarnya cairan yang tidak normal. Kucing dan anjing sehat biasanya memiliki pandangan yang jelas dan responsif terhadap lingkungan sekitarnya. Rutin pemeriksaan mata dapat menjaga kesehatan mata mereka.",
+            "treatment": "Untuk menjaga mata tetap sehat, pembersihan rutin dengan lap lembab untuk menghapus kotoran atau lendir yang terkumpul adalah penting. Tetes mata yang direkomendasikan oleh dokter hewan bisa digunakan untuk membersihkan mata atau mencegah iritasi. Diet sehat dengan nutrisi yang mencakup vitamin A, seperti wortel, juga membantu menjaga kesehatan mata. Pemeriksaan rutin oleh dokter hewan akan membantu mendeteksi masalah mata sejak dini. Jika ada kondisi seperti infeksi atau penyakit mata, pengobatan akan disesuaikan dengan diagnosa yang tepat, mungkin melalui obat tetes mata atau pengobatan oral, yang akan diresepkan oleh dokter hewan.",
+            "information": "Terkait perawatan mata, perhatikan perilaku mereka. Jika terjadi gosok-gosok mata berlebihan, mata merah, keluar cairan yang tidak normal, atau gejala lain seperti kepekaan terhadap cahaya atau penglihatan buram, segera konsultasikan dengan dokter hewan. Mata kucing dan anjing rentan terhadap infeksi, luka, atau kondisi medis lainnya. Jangan gunakan produk atau obat tanpa rekomendasi dokter hewan, karena dapat memperburuk masalah mata. Serta, hindari penggunaan cairan atau bahan yang tidak aman atau tajam di sekitar mata hewan peliharaan untuk mencegah cedera. Pemeliharaan rutin dan perhatian terhadap mata dapat mencegah masalah yang lebih serius."
+        }
+    ]
+}

modules.tf

@@ -0,0 +1,109 @@
+# PostgreSQL Password Secret
+module "postgres_password_secret" {
+    source = "./modules/secrets"
+    secret_project_id = var.project_id
+    secret_id = "postgres-password-secret"
+    secret_data = var.postgres_password
+}
+
+# JWT Public Key Secret
+module "public_key_secret" {
+    source = "./modules/secrets"
+    secret_project_id = var.project_id
+    secret_id = "public-key-secret"
+    secret_data = var.jwt_public_key
+}
+
+# JWT Private Key Secret
+module "private_key_secret" {
+    source = "./modules/secrets"
+    secret_project_id = var.project_id
+    secret_id = "private-key-secret"
+    secret_data = var.jwt_private_key
+}
+
+# Docpet Backend Service (Cloud Run)
+module "docpet_service_cloud_run" {
+    source = "./modules/cloud_run"
+    cloud_run_name = var.service_name
+
+    cloud_run_project = var.project_id
+
+    cloud_run_description = <<-EOT
+        Docpet Backend Service
+    EOT
+
+    cloud_run_location = var.region
+    cloud_run_ingress  = "INGRESS_TRAFFIC_ALL"
+
+    # cloud_run_revision = var.revision_name
+
+    cloud_run_service_account = var.service_account
+    
+    cloud_run_image = var.service_container
+    cloud_run_port  = 80
+
+    cloud_run_cpu = "4.0"
+    cloud_run_memory = "4Gi"
+    cloud_run_cpu_idle = true
+    cloud_run_cpu_boost = true
+
+    cloud_run_startup_probe = {
+        http_path = "/api/checker"
+        http_port = 80
+
+        period_seconds = 240
+        timeout_seconds = 240
+        failure_threshold = 20
+        initial_delay_seconds = 240
+    }
+
+    cloud_run_liveness_probe = {
+        http_path = "/api/checker"
+        http_port = 80
+
+        period_seconds = 240
+        timeout_seconds = 5
+        failure_threshold = 5
+        initial_delay_seconds = 10
+    }
+
+    cloud_run_timeout = 800
+    cloud_run_max_instance_concurrent = 80
+    cloud_run_execution_environment = "EXECUTION_ENVIRONMENT_GEN1"
+
+    cloud_run_min_instance = 0
+    cloud_run_max_instance = 15
+
+    cloud_run_traffic_percent = 100
+    cloud_run_traffic_type = "TRAFFIC_TARGET_ALLOCATION_TYPE_LATEST"
+
+    cloud_run_vpc_access_connector = var.vpc_access_connector
+    cloud_run_vpc_access_egress = "PRIVATE_RANGES_ONLY"
+
+    cloud_run_envars = {
+        DATABASE_PORT = var.postgres_port
+        POSTGRES_USER = var.postgres_user
+        POSTGRES_DB = var.postgres_db
+        POSTGRES_HOST = var.postgres_host
+        POSTGRES_HOSTNAME = var.postgres_hostname
+
+        ACCESS_TOKEN_EXPIRES_IN = var.access_token_expires
+        REFRESH_TOKEN_EXPIRES_IN = var.refresh_token_expires
+        JWT_ALGORITHM = var.jwt_algorithm
+        CLIENT_ORIGIN = "*"
+
+        JWT_PUBLIC_KEY = module.public_key_secret.secret_id_output
+        JWT_PRIVATE_KEY = module.private_key_secret.secret_id_output
+        POSTGRES_PASSWORD = module.postgres_password_secret.secret_id_output
+    }
+}
+
+# Cloud Run Service IAM
+resource "google_cloud_run_service_iam_binding" "cloud_run_service_iam" {
+    project = var.project_id
+    location = var.region
+    service = module.docpet_service_cloud_run.cloud_run_service_name_output
+    role = "roles/run.invoker"
+    members = ["allUsers"]
+}

modules/cloud_run/cloud_run.tf

@@ -0,0 +1,167 @@
+# Cloud Run Service
+resource "google_cloud_run_v2_service" "cloud_run_service" {
+    name = var.cloud_run_name
+    project = var.cloud_run_project
+    description = var.cloud_run_description
+
+    location = var.cloud_run_location
+    ingress = var.cloud_run_ingress
+
+    template {
+        # revision = var.cloud_run_revision
+        service_account = var.cloud_run_service_account
+
+        containers {
+            image = var.cloud_run_image
+
+            ports {
+                container_port = var.cloud_run_port
+            }
+            
+            resources {
+                limits = {
+                    cpu = var.cloud_run_cpu
+                    memory = var.cloud_run_memory
+                }
+
+                cpu_idle = var.cloud_run_cpu_idle
+                startup_cpu_boost = var.cloud_run_cpu_boost
+            }
+
+            # startup_probe {
+            #     period_seconds = var.cloud_run_startup_probe["period_seconds"]
+            #     timeout_seconds = var.cloud_run_startup_probe["timeout_seconds"]
+            #     failure_threshold = var.cloud_run_startup_probe["failure_threshold"]
+            #     initial_delay_seconds = var.cloud_run_startup_probe["initial_delay_seconds"]
+
+            #     http_get {
+            #         path = var.cloud_run_startup_probe["http_path"]
+            #         port = var.cloud_run_startup_probe["http_port"]
+            #     }
+            # }
+
+            liveness_probe {
+                period_seconds = var.cloud_run_liveness_probe["period_seconds"]
+                timeout_seconds = var.cloud_run_liveness_probe["timeout_seconds"]
+                failure_threshold = var.cloud_run_liveness_probe["failure_threshold"]
+                initial_delay_seconds = var.cloud_run_liveness_probe["initial_delay_seconds"]
+
+                http_get {
+                    path = var.cloud_run_liveness_probe["http_path"]
+                    port = var.cloud_run_liveness_probe["http_port"]
+                }
+            }
+
+            # Environment Variables
+            env {
+                name = "DATABASE_PORT"
+                value = var.cloud_run_envars["DATABASE_PORT"]
+            }
+
+            env {
+                name = "POSTGRES_USER"
+                value = var.cloud_run_envars["POSTGRES_USER"]
+            }
+
+            env {
+                name = "POSTGRES_DB"
+                value = var.cloud_run_envars["POSTGRES_DB"]
+            }
+
+            env {
+                name = "POSTGRES_HOST"
+                value = var.cloud_run_envars["POSTGRES_HOST"]
+            }
+
+            env {
+                name = "POSTGRES_HOSTNAME"
+                value = var.cloud_run_envars["POSTGRES_HOSTNAME"]
+            }
+
+            env {
+                name = "ACCESS_TOKEN_EXPIRES_IN"
+                value = var.cloud_run_envars["ACCESS_TOKEN_EXPIRES_IN"]
+            }
+
+            env {
+                name = "REFRESH_TOKEN_EXPIRES_IN"
+                value = var.cloud_run_envars["REFRESH_TOKEN_EXPIRES_IN"]
+            }
+
+            env {
+                name = "JWT_ALGORITHM"
+                value = var.cloud_run_envars["JWT_ALGORITHM"]
+            }
+
+            env {
+                name = "CLIENT_ORIGIN"
+                value = var.cloud_run_envars["CLIENT_ORIGIN"]
+            }
+
+
+            # Secrets
+            env {
+                name = "JWT_PUBLIC_KEY"
+                value_source {
+                    secret_key_ref {
+                        # secret = google_secret_manager_secret.secret.secret_id
+                        secret = var.cloud_run_envars["JWT_PUBLIC_KEY"]
+                        version = "1"
+                    }
+                }
+            }
+
+            env {
+                name = "JWT_PRIVATE_KEY"
+                value_source {
+                    secret_key_ref {
+                        # secret = google_secret_manager_secret.secret.secret_id
+                        secret = var.cloud_run_envars["JWT_PRIVATE_KEY"]
+                        version = "1"
+                    }
+                }
+            }
+
+            env {
+                name = "POSTGRES_PASSWORD"
+                value_source {
+                    secret_key_ref {
+                        # secret = google_secret_manager_secret.secret.secret_id
+                        secret = var.cloud_run_envars["POSTGRES_PASSWORD"]
+                        version = "1"
+                    }
+                }
+            }
+        }
+
+        timeout = "${
+            var.cloud_run_timeout
+        }s"
+
+        max_instance_request_concurrency = var.cloud_run_max_instance_concurrent
+        execution_environment = var.cloud_run_execution_environment
+
+        scaling {
+            min_instance_count = var.cloud_run_min_instance
+            max_instance_count = var.cloud_run_max_instance
+        }
+
+        vpc_access {
+            # projects/{project}/locations/{location}/connectors/{connector}
+            connector = "projects/${
+                var.cloud_run_project
+            }/locations/${
+                var.cloud_run_location
+            }/connectors/${
+                var.cloud_run_vpc_access_connector
+            }"
+
+            egress = var.cloud_run_vpc_access_egress
+        }
+    }
+
+    traffic {
+        percent = var.cloud_run_traffic_percent
+        type = var.cloud_run_traffic_type
+    }
+}

modules/cloud_run/outputs.tf

@@ -0,0 +1,5 @@
+# Cloud Run Service Name Output
+output "cloud_run_service_name_output" {
+    value = google_cloud_run_v2_service.cloud_run_service.name
+    description = "Cloud Run Service Name Output <type: String>"
+}

modules/cloud_run/variables.tf

@@ -0,0 +1,256 @@
+# Cloud Run Name
+variable "cloud_run_name" {
+    type = string
+    default = "cloud_run_service"
+    description = "Cloud Run Name <type: String>"
+}
+
+# Cloud Run Project ID
+variable "cloud_run_project" {
+    type = string
+    description = "Cloud Run Project ID <type: String>"
+}
+
+# Cloud Run Description
+variable "cloud_run_description" {
+    type = string
+    default = <<-EOT
+        this is service for blablabla
+    EOT
+
+    description = "Cloud Run Description <type: String>"
+}
+
+# Cloud Run Location
+variable "cloud_run_location" {
+    type = string
+    default = "asia-southeast2"
+    description = "Cloud Run Location <type: String>"
+}
+
+# Cloud Run Ingress
+variable "cloud_run_ingress" {
+    type = string
+    default = "INGRESS_TRAFFIC_ALL"
+    description = "value"
+}
+
+# Cloud Run Revision
+variable "cloud_run_revision" {
+    type = string
+    default = "revision-service-xxxxx"
+    description = "Cloud Run Revision <type: String>"
+}
+
+# Cloud Run Service Account
+variable "cloud_run_service_account" {
+    type = string
+    description = "Cloud Run Service Account <type: String>"
+}
+
+# Cloud Run Container Image
+variable "cloud_run_image" {
+    type = string
+    default = "us-docker.pkg.dev/cloudrun/container/hello"
+    description = "Cloud Run Container Image <type: String>"
+}
+
+# Cloud Run Port
+variable "cloud_run_port" {
+    type = number
+    default = 80
+    description = "Cloud Run Port <type: Number>"
+}
+
+# Cloud Run vCPU Limit
+variable "cloud_run_cpu" {
+    type = string
+    default = "2m"
+    description = "Cloud Run vCPU limit <type: String>"
+}
+
+# Cloud Run Memory Limit
+variable "cloud_run_memory" {
+    type = string
+    default = "2Gi"
+    description = "Cloud Run Memory Limit <type: String>"
+}
+
+# Cloud Run CPU Idle
+variable "cloud_run_cpu_idle" {
+    type = bool
+    default = true
+    description = "Cloud Run CPU Idle <type: Bool>"
+}
+
+# Cloud Run StartUp CPU Boost
+variable "cloud_run_cpu_boost" {
+    type = bool
+    default = true
+    description = "Cloud Run StartUp CPU Boost <type: String>"
+}
+
+# Cloud Run StartUp Probe
+variable "cloud_run_startup_probe" {
+    type = map(any)
+
+    default = {
+        http_path = "/"
+        http_port = 80
+
+        period_seconds = 240
+        timeout_seconds = 5
+        failure_threshold = 5
+        initial_delay_seconds = 10
+    }
+
+    description =<<-EOT
+        Cloud Run StartUp Probe <type: Map(Any)>
+        Example: 
+           cloud_run_startup_probe = {
+             http_path = "/"
+             http_port = 80
+
+             period_seconds = 240
+             timeout_seconds = 5
+             failure_threshold = 5
+             initial_delay_seconds = 10
+           } 
+    EOT
+}
+
+# Cloud Run Liveness Probe
+variable "cloud_run_liveness_probe" {
+    type = map(any)
+
+    default = {
+        http_path = "/"
+        http_port = 80
+
+        period_seconds = 240
+        timeout_seconds = 5
+        failure_threshold = 5
+        initial_delay_seconds = 10
+    }
+
+    description =<<-EOT
+        Cloud Run Liveness Probe <type: Map(Any)>
+        Example: 
+           cloud_run_startup_probe {
+             http_path = "/"
+             http_port = 80
+
+             period_seconds = 240
+             timeout_seconds = 5
+             failure_threshold = 5
+             initial_delay_seconds = 10
+           } 
+    EOT
+}
+
+# Cloud Run Timeout
+variable "cloud_run_timeout" {
+    type = number
+    default = 800
+    description = "Cloud Run Timeout <type: Number>"
+}
+
+# Cloud Run Max Instance Request Concurrency
+variable "cloud_run_max_instance_concurrent" {
+    type = number
+    default = 80
+    description = "Cloud Run Max Instance Request Concurrency <type: Number>"
+}
+
+# Cloud Run Execution Environment
+variable "cloud_run_execution_environment" {
+    type = string
+    default = "EXECUTION_ENVIRONMENT_GEN1"
+    description = "Cloud Run Execution Environment <type: String>"
+}
+
+# Cloud Run Min Instance
+variable "cloud_run_min_instance" {
+    type = number
+    default = 0
+    description = "Cloud Run Min Instance <type: Number>"
+}
+
+# Cloud Run Max Instance
+variable "cloud_run_max_instance" {
+    type = number
+    default = 15
+    description = "Cloud Run Max Instance <type: Number>"
+}
+
+# Cloud Run Traffic Percent
+variable "cloud_run_traffic_percent" {
+    type = number
+    default = 100
+    description = "Cloud Run Traffic Percent <type: Number>"
+}
+
+# Cloud Run Traffic Type
+variable "cloud_run_traffic_type" {
+    type = string
+    default = "TRAFFIC_TARGET_ALLOCATION_TYPE_LATEST"
+    description = "Cloud Run Traffic Type <type: String>"
+}
+
+# Cloud Run Connector
+variable "cloud_run_vpc_access_connector" {
+    type = string
+    default = "project-vpc-connector"
+    description = "Cloud Run Connector <type: String>"
+}
+
+# Cloud Run VPC Access Egress
+variable "cloud_run_vpc_access_egress" {
+    type = string
+    default = "ALL_TRAFFIC"
+    description = "Cloud Run VPC Access Egress <type: String>"
+}
+
+# Cloud Run Environment Variables
+variable "cloud_run_envars" {
+    type = map(string)
+    sensitive = true
+
+    default = {
+        DATABASE_PORT = "5432"
+        POSTGRES_USER = "postgres"
+        POSTGRES_DB = "dbname"
+        POSTGRES_HOST = "postgres"
+        POSTGRES_HOSTNAME = "127.0.0.1"
+
+        ACCESS_TOKEN_EXPIRES_IN = "15"
+        REFRESH_TOKEN_EXPIRES_IN = "60"
+        JWT_ALGORITHM = "RS256"
+        CLIENT_ORIGIN = "*"
+
+        JWT_PUBLIC_KEY = "<jwt public key>"
+        JWT_PRIVATE_KEY = "<jwt private key>"
+        POSTGRES_PASSWORD = "secret value"
+    }
+
+    description =<<-EOT
+        Cloud Run Environment Variables <type: map(String)>
+        Example:
+            cloud_run_envars = {
+                DATABASE_PORT = "5432"
+                POSTGRES_USER = "postgres"
+                POSTGRES_DB = "docpet"
+                POSTGRES_HOST = "postgres"
+                POSTGRES_HOSTNAME = "127.0.0.1"
+
+                ACCESS_TOKEN_EXPIRES_IN = "15"
+                REFRESH_TOKEN_EXPIRES_IN = "60"
+                JWT_ALGORITHM = "RS256"
+                CLIENT_ORIGIN = "*"
+
+                JWT_PUBLIC_KEY = "<jwt public key>"
+                JWT_PRIVATE_KEY = "<jwt private key>"
+                POSTGRES_PASSWORD = "secret value"
+            }
+    EOT
+}

modules/secrets/outputs.tf

@@ -0,0 +1,11 @@
+# Secret ID Output
+output "secret_id_output" {
+    value = google_secret_manager_secret.secret_manager.secret_id
+    description = "Secret ID Output <type: String>"
+}
+
+# Secret Version Output
+output "secret_version_output" {
+    value = google_secret_manager_secret_version.secret_manager_version
+    description = "Secret Version Output <type: Resource>"
+}

modules/secrets/secrets.tf

@@ -0,0 +1,28 @@
+data "google_project" "project" {
+    project_id = var.secret_project_id
+}
+
+resource "google_secret_manager_secret" "secret_manager" {
+    secret_id = var.secret_id
+    replication {
+        auto {}
+    }
+}
+
+resource "google_secret_manager_secret_version" "secret_manager_version" {
+    secret = google_secret_manager_secret.secret_manager.name
+    secret_data = var.secret_data
+}
+
+resource "google_secret_manager_secret_iam_member" "secret_manager_iam_member" {
+    secret_id = google_secret_manager_secret.secret_manager.id
+    member = "serviceAccount:${
+        data.google_project.project.number
+    }-compute@developer.gserviceaccount.com"
+
+    role = "roles/secretmanager.secretAccessor"
+
+    depends_on = [
+        google_secret_manager_secret.secret_manager
+    ]
+}

modules/secrets/variables.tf

@@ -0,0 +1,19 @@
+# Secret Project ID
+variable "secret_project_id" {
+    type = string
+    description = "Secret Project ID <type: String>"
+}
+
+# Secret ID
+variable "secret_id" {
+    type = string
+    default = "secret-aBcDeFg"
+    description = "Secret ID <type: String>"
+}
+
+# Secret Data (SENSITIVE)
+variable "secret_data" {
+    type = string
+    sensitive = true
+    description = "Secret Data (SENSITIVE) <type: String>"
+}

requirements/freebsd.requirements.txt

@@ -0,0 +1,90 @@
+absl-py==2.0.0
+aiosmtplib==1.1.7
+alembic==1.9.0
+anyio==3.6.2
+astunparse==1.6.3
+bcrypt==4.0.1
+blinker==1.5
+cachetools==5.3.2
+certifi==2022.12.7
+cffi==1.15.1
+charset-normalizer==3.3.2
+click==8.1.3
+colorama==0.4.6
+cryptography==3.4.8
+dnspython==2.2.1
+email-validator==1.3.0
+fastapi==0.87.0
+fastapi-jwt-auth==0.5.0
+fastapi-mail==1.2.2
+flatbuffers==23.5.26
+gast==0.4.0
+google-api-core==2.14.0
+google-auth==2.25.0
+google-auth-oauthlib==1.0.0
+google-cloud-core==2.3.3
+google-cloud-storage==2.13.0
+google-crc32c==1.5.0
+google-pasta==0.2.0
+google-resumable-media==2.6.0
+googleapis-common-protos==1.61.0
+greenlet==2.0.1
+grpcio==1.59.3
+h11==0.14.0
+h5py==3.10.0
+httpcore==0.16.3
+httptools==0.5.0
+httpx==0.23.1
+idna==3.4
+importlib-metadata==7.0.0
+itsdangerous==2.1.2
+jax==0.4.21
+Jinja2==3.1.2
+keras==2.12.0
+Keras-Preprocessing==1.1.2
+libclang==16.0.6
+Mako==1.2.4
+Markdown==3.5.1
+MarkupSafe==2.1.1
+ml-dtypes==0.3.1
+numpy==1.23.5
+oauthlib==3.2.2
+opt-einsum==3.3.0
+orjson==3.8.3
+packaging==23.2
+passlib==1.7.4
+Pillow==10.1.0
+protobuf==4.25.1
+psycopg2==2.9.5
+pyasn1==0.5.1
+pyasn1-modules==0.3.0
+pycparser==2.21
+pydantic==1.10.2
+PyJWT==1.7.1
+python-dotenv==0.21.0
+python-multipart==0.0.5
+PyYAML==6.0
+requests==2.31.0
+requests-oauthlib==1.3.1
+rfc3986==1.5.0
+rsa==4.9
+scipy==1.11.4
+six==1.16.0
+sniffio==1.3.0
+SQLAlchemy==1.4.45
+starlette==0.21.0
+tensorboard==2.12.3
+tensorboard-data-server==0.7.2
+tensorflow==2.12.0
+tensorflow-estimator==2.12.0
+tensorflow-io-gcs-filesystem==0.31.0
+termcolor==2.4.0
+typing_extensions==4.4.0
+ujson==5.6.0
+urllib3==2.1.0
+uvicorn==0.20.0
+watchfiles==0.18.1
+websockets==10.4
+Werkzeug==3.0.1
+wrapt==1.14.1
+zipp==3.17.0