feat: convert to libsql database and use raw SQL, update docker build

.github/workflows/build.yml

@@ -0,0 +1,36 @@
+name: Deploy
+
+on:
+  push:
+    branches:
+      - main
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Log in to the Container registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

.gitignore

@@ -1 +1,3 @@
 .env
+sqlite.db*
+

.python-version

@@ -0,0 +1 @@
+3.13

Dockerfile

@@ -1,25 +1,31 @@
-# syntax=docker/dockerfile:1
-FROM python:3.11-slim as build
-
-# Setup ENV variables here (if needed in the future)
-# Install pipenv
-RUN pip3 install pipenv
-# Install python dependencies in /.venv
-COPY Pipfile .
-COPY Pipfile.lock .
-RUN PIPENV_VENV_IN_PROJECT=1 pipenv install --deploy
-# Install app into container
-FROM python:3.11-slim as runtime
-WORKDIR /bot
-COPY --from=build /.venv /.venv
-COPY --from=build root/.cache /home/botuser/.cache
-COPY . .
-ENV PATH="/.venv/bin:$PATH"
-# Create a non-root user and add permission to access /bot folder
-RUN useradd botuser && \
-  chown -R botuser /bot && chown -R botuser /home/botuser && chown -R botuser /.venv
-USER botuser
-RUN prisma generate && prisma py fetch
-
-# Run the app
-CMD ["python3", "bot.py" ]
+# Use a Python image with uv pre-installed
+FROM ghcr.io/astral-sh/uv:python3.13-bookworm-slim
+
+# Install the project into `/app`
+WORKDIR /app
+
+# Enable bytecode compilation
+ENV UV_COMPILE_BYTECODE=1
+
+# Copy from the cache instead of linking since it's a mounted volume
+ENV UV_LINK_MODE=copy
+
+# Install the project's dependencies using the lockfile and settings
+RUN --mount=type=cache,target=/root/.cache/uv \
+    --mount=type=bind,source=uv.lock,target=uv.lock \
+    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
+    uv sync --frozen --no-install-project --no-dev
+
+# Then, add the rest of the project source code and install it
+# Installing separately from its dependencies allows optimal layer caching
+COPY pyproject.toml uv.lock bot.py /app
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --frozen --no-dev
+
+# Place executables in the environment at the front of the path
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Reset the entrypoint, don't invoke `uv`
+ENTRYPOINT []
+
+CMD ["python3", "bot.py"]

bot.py

@@ -1,11 +1,11 @@
+#!/usr/bin/env python
 from datetime import datetime, timedelta
 import os
-import time
 from typing import Tuple
 import asyncio
 import re
 import requests
-from dotenv import load_dotenv
+import libsql_client
 from telegram import Update
 from telegram.ext import (
     ApplicationBuilder,
@@ -15,17 +15,28 @@
     PollHandler,
     filters,
 )
-from prisma import Prisma
-from prisma.models import WeatherIcon
 
 LOOP = asyncio.get_event_loop()
-load_dotenv()
 POLL_TIME = timedelta(minutes=10)
-BOT_TOKEN = os.getenv("BOT_TOKEN")
-WEATHER_API = os.getenv("WEATHER_API")
+BOT_TOKEN = os.getenv("BOT_TOKEN", "")
+WEATHER_API = os.getenv("WEATHER_API", "")
+DB_URL = os.getenv("DATABASE_URL", "http://127.0.0.1:8080")
+DB_TOKEN = os.getenv("DATABASE_TOKEN")
 if not BOT_TOKEN or not WEATHER_API:
     print("env variables missing")
-weather_code_dict: dict[str, Tuple[WeatherIcon, datetime]] = {}
+
+
+class WeatherStatus:
+    def __init__(
+        self, code: int, temperature: int, votes_yes: int, votes_no: int
+    ) -> None:
+        self.code = code
+        self.temperature = temperature
+        self.votes_yes = votes_yes
+        self.votes_no = votes_no
+
+
+weather_code_dict: dict[str, Tuple[WeatherStatus, datetime]] = {}
 poll_created_dict: dict[int, Tuple[int, datetime]] = {}
 
 word_filter = [
@@ -123,7 +134,8 @@ async def day(update: Update, context: ContextTypes.DEFAULT_TYPE):
     if not res:
         res, timestamp = await add_data_to_db(code, temp_rounded, 1, 1)
     if not res:
-        await update.effective_chat.send_message(f"Error occurred, send help.")
+        await update.effective_chat.send_message("Error occurred, send help.")
+        return
     weather_code_dict[code] = (res, timestamp)
     beautiful_pct = res.votes_yes / (res.votes_no + res.votes_yes) * 100
     beautiness = "Kaunis" if beautiful_pct > 50 else "Ei kaunis"
@@ -192,55 +204,58 @@ async def handle_poll_ended(update: Update, context: ContextTypes.DEFAULT_TYPE):
 
 
 async def add_data_to_db(code: int, temp_rounded: int, yes_amount: int, no_amount: int):
-    db = Prisma()
-    try:
-        await db.connect()
-        res = await db.weathericon.find_first(
-            where={"code": code, "temperature": temp_rounded}
-        )
-        if not res:
-            res = await db.weathericon.create(
-                data={
-                    "code": code,
-                    "temperature": temp_rounded,
-                    "votes_yes": yes_amount,
-                    "votes_no": no_amount,
-                }
-            )
-        else:
-            await db.weathericon.update_many(
-                where={
-                    "code": code,
-                    "temperature": temp_rounded,
-                },
-                data={
-                    "votes_yes": {"increment": yes_amount},
-                    "votes_no": {"increment": no_amount},
-                },
+    async with libsql_client.create_client(
+        url=DB_URL, auth_token=DB_TOKEN
+    ) as db_client:
+        try:
+            db_res = await db_client.execute(
+                "select code, temperature, votes_yes, votes_no from weather_status where code=? and temperature =?",
+                [code, temp_rounded],
             )
-    except Exception as e:
-        print(e)
-        return None, datetime.now() - timedelta(minutes=10)
-    finally:
-        await db.disconnect()
-    return res, datetime.now()
+            if not db_res.rows:
+                db_res = await db_client.execute(
+                    "INSERT INTO weather_status(code,temperature,votes_yes,votes_no) VALUES(?,?,?,?) returning *",
+                    [code, temp_rounded, yes_amount, no_amount],
+                )
+            else:
+                db_res = await db_client.execute(
+                    "UPDATE weather_status SET votes_yes = votes_yes + ?, votes_no = votes_no + ? WHERE code =? AND temperature=? returning *",
+                    [yes_amount, no_amount, code, temp_rounded],
+                )
+        except Exception as e:
+            print(e)
+            return None, datetime.now() - timedelta(minutes=10)
+        row = db_res.rows[0]
+        res = WeatherStatus(
+            int(row["code"]),
+            int(row["temperature"]),
+            int(row["votes_yes"]),
+            int(row["votes_no"]),
+        )
+        return res, datetime.now()
 
 
 async def fetch_from_db(code: str, temp_rounded: int):
-    db = Prisma()
-    try:
-        await db.connect()
-        db_res = await db.weathericon.find_first(
-            where={"code": code, "temperature": temp_rounded}
+    async with libsql_client.create_client(
+        url=DB_URL, auth_token=DB_TOKEN
+    ) as db_client:
+        db_res = await db_client.execute(
+            "select code, temperature, votes_yes, votes_no from weather_status where code=? and temperature=?",
+            [code, temp_rounded],
         )
-        if not db_res:
-            db_res = await db.weathericon.create(
-                {"code": code, "temperature": temp_rounded}
+        if not db_res.rows:
+            db_res = await db_client.execute(
+                "INSERT INTO weather_status(code,temperature,votes_yes,votes_no) VALUES(?,?,1,1) returning *",
+                [code, temp_rounded],
             )
-    finally:
-        if db.is_connected():
-            await db.disconnect()
-    return db_res, datetime.now()
+        row = db_res[0]
+        res = WeatherStatus(
+            int(row["code"]),
+            int(row["temperature"]),
+            int(row["votes_yes"]),
+            int(row["votes_no"]),
+        )
+        return res, datetime.now()
 
 
 def main():

pyproject.toml

@@ -0,0 +1,11 @@
+[project]
+name = "paivabot"
+version = "0.1.0"
+description = "bot to tell weather + give an educated guess if the day is beautiful or not"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "libsql-client>=0.3.1",
+    "python-telegram-bot>=21.9",
+    "requests>=2.32.3",
+]