finalized auth

app.py

@@ -111,15 +111,11 @@ class Summarizer:
 
     def get_pipe(self, lang: str):
         logger.info(f"Pipe language: {lang}")
-        summary = {
-            "en": self.en_summary_pipe,
-            "ru": self.ru_summary_pipe,
-        }
-        sentiment = {
-            "en": self.en_sentiment_pipe,
-            "ru": self.ru_sentiment_pipe,
-        }
-        return summary[lang], sentiment[lang]
+        if lang == "en":
+            return self.en_summary_pipe, self.en_sentiment_pipe
+        if lang == "ru":
+            return self.ru_summary_pipe, self.ru_sentiment_pipe
+        raise ValueError(f"Language {lang} is not supported")
 
     def summarize(self, req: TextRequest, lang: str = "en") -> Result:
         sum_pipe, sent_pipe = self.get_pipe(lang)
@@ -134,7 +130,7 @@ class Summarizer:
         )
         return result
 
-    def summ(self, req: TextRequest, lang: str = "en") -> str:
+    def get_summary(self, req: TextRequest, lang: str = "en") -> str:
         return self.summarize(req, lang).to_str()
 
 
@@ -185,12 +181,12 @@ if __name__ == "__main__":
                 ru_inbtn = gr.Button("Запустить")
 
         en_inbtn.click(
-            pipe.summ,
+            pipe.get_summary,
             [en_inputs, en_lang],
             [en_outputs],
         )
         ru_inbtn.click(
-            pipe.summ,
+            pipe.get_summary,
             [ru_inputs, ru_lang],
             [ru_outputs],
         )

main.py

@@ -1,46 +1,62 @@
-import os
-import gradio as gr
 import random
-import secrets
-from typing import Annotated
-from fastapi import FastAPI, Request, status, Depends
+import gradio as gr
+
+# from fastapi.security import APIKeyHeader
+from fastapi import FastAPI, Request, Depends
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import HTMLResponse, RedirectResponse
 from fastapi.templating import Jinja2Templates
-from fastapi.exceptions import HTTPException
-from fastapi.security import HTTPBasic, HTTPBasicCredentials
 from loguru import logger
-from dotenv import load_dotenv
-
-from app import Summarizer, TextRequest, Result
+from app import Summarizer, TextRequest
 from app import (
     EN_SENTIMENT_MODEL,
     EN_SUMMARY_MODEL,
-    RU_SENTIMENT_MODEL,
-    RU_SUMMARY_MODEL,
 )
-from app import DEFAULT_EN_TEXT, DEFAULT_RU_TEXT
+from app import DEFAULT_EN_TEXT
 from models.forms import VerificationForm
+from models.exceptions import MyHTTPException, my_http_exception_handler
+from models.security import AuthUsers
 
-load_dotenv()
-
-SITE_KEY = os.getenv("SITE_KEY")
-API_USER = os.getenv("API_USER")
-API_PWD = os.getenv("API_PWD")
-users = set()
 
 app = FastAPI()
 pipe = Summarizer()
-security = HTTPBasic()
+users = AuthUsers()
 
-# mount FastAPI StaticFiles server
 app.mount("/static", StaticFiles(directory="static"), name="static")
 templates = Jinja2Templates(directory="templates")
 
-
-@app.get("/")
-async def index(request: Request):
-    return RedirectResponse("/index/", status_code=302)
+# auth_header = APIKeyHeader(name="Authorization", auto_error=True)
+# router = APIRouter(
+#     prefix="/v1",
+#     tags=["API v1"],
+#     dependencies=[Security(auth_header)],
+# )
+# app.include_router(router)
+
+app.add_exception_handler(MyHTTPException, my_http_exception_handler)
+
+
+@app.middleware("http")
+async def add_process_time_header(request: Request, call_next):
+    response = await call_next(request)
+    token = request.cookies.get("Authorization")
+    dest = request.url.path.split("/")[-1]
+    resp_headers = dict(response.headers)
+    cont_type = resp_headers.get("content-type")
+    if (
+        not cont_type
+        or "text/html" not in cont_type
+        or dest
+        in [
+            "docs",
+            "verify_page",
+            "verify",
+        ]
+    ):
+        return response
+    if not token or token == "":
+        return RedirectResponse("/verify_page", status_code=307)
+    return response
 
 
 @app.get("/verify_page", response_class=HTMLResponse)
@@ -49,143 +65,71 @@ async def verify_page(request: Request):
     return templates.TemplateResponse(
         request=request,
         name="verification.html",
-        context={"site_key": SITE_KEY, "captcha_id": captcha_id},
+        context={"captcha_id": captcha_id},
     )
 
 
 @app.post("/verify")
-async def verify(request: Request):
+async def verify(request: Request, checked_user: bool = Depends(users.get_cookie_data)):
     form = VerificationForm(request)
     await form.load_data()
     if await form.is_valid():
         logger.info("Form is valid")
-        return RedirectResponse("/index/", status_code=302)
+        response = RedirectResponse("/index", status_code=302)
+        if not checked_user:
+            user_token = users.generate_user_token()
+            users.add_user_session(user_token)
+            response.set_cookie(key="Authorization", value=user_token)
+            logger.info(f"Issued token: {user_token}")
+        return response
+    logger.info("Validation error")
     return await verify_page(request)
 
 
-def get_current_username(
-    credentials: Annotated[HTTPBasicCredentials, Depends(security)]
-):
-    current_username_bytes = credentials.username.encode("utf8")
-    correct_username_bytes = bytes(API_USER, "utf-8")
-    is_correct_username = secrets.compare_digest(
-        current_username_bytes, correct_username_bytes
-    )
-    current_password_bytes = credentials.password.encode("utf8")
-    correct_password_bytes = bytes(API_PWD, "utf-8")
-    is_correct_password = secrets.compare_digest(
-        current_password_bytes, correct_password_bytes
-    )
-    if not (is_correct_username and is_correct_password):
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Incorrect username or password",
-            headers={"WWW-Authenticate": "Basic"},
-        )
-    return credentials.username
-
-
-@app.post("/summ_ru", response_model=Result)
-async def ru_summ_api(
-    request: TextRequest, username: Annotated[str, Depends(get_current_username)]
-):
-    results = pipe.summarize(request.text, lang="ru")
-    logger.info(results)
-    return results
-
-
-@app.post("/summ_en", response_model=Result)
-async def en_summ_api(
-    request: TextRequest, username: Annotated[str, Depends(get_current_username)]
-):
-    results = pipe.summarize(request.text, lang="en")
-    logger.info(results)
-    return results
-
-
-@app.exception_handler(403)
-async def unavailable_error(request: Request, exc: HTTPException):
-    logger.warning("Error 403")
-    return templates.TemplateResponse(
-        "errors/error.html",
-        {"request": request, "message": "403. Sorry, this page unavailable."},
-        status_code=403,
-    )
-
+@app.get("/")
+async def get_main_page():
+    return RedirectResponse("/index", status_code=302)
 
-@app.exception_handler(404)
-async def not_found_error(request: Request, exc: HTTPException):
-    logger.warning("Error 404")
-    return templates.TemplateResponse(
-        "errors/error.html",
-        {"request": request, "message": "404. Page Not Found."},
-        status_code=404,
-    )
 
-
-@app.exception_handler(500)
-async def internal_error(request: Request, exc: HTTPException):
-    logger.warning("Error 500")
-    return templates.TemplateResponse(
-        "errors/error.html",
-        {"request": request, "message": "500. Oops. Something has gone wrong."},
-        status_code=500,
-    )
+def get_summary(text: TextRequest, lang: str, request: gr.Request):
+    token = request.cookies["Authorization"]
+    if users.verify_user(token):
+        users.add_user_session(token)
+        return pipe.get_summary(text, lang)
+    logger.info("User not verified")
+    return "Sorry. You are not verified."
 
 
 with gr.Blocks() as demo:
-    with gr.Row():
-        with gr.Column(scale=2, min_width=600):
-            en_sum_description = gr.Markdown(
-                value=f"Model for Summary: {EN_SUMMARY_MODEL}"
-            )
-            en_sent_description = gr.Markdown(
-                value=f"Model for Sentiment: {EN_SENTIMENT_MODEL}"
-            )
-            en_inputs = gr.Textbox(
-                label="en_input",
-                lines=5,
-                value=DEFAULT_EN_TEXT,
-                placeholder=DEFAULT_EN_TEXT,
-            )
-            en_lang = gr.Textbox(value="en", visible=False)
-            en_outputs = gr.Textbox(
-                label="en_output",
-                lines=5,
-                placeholder="Summary and Sentiment would be here...",
-            )
-            en_inbtn = gr.Button("Proceed")
-        with gr.Column(scale=2, min_width=600):
-            ru_sum_description = gr.Markdown(
-                value=f"Model for Summary: {RU_SUMMARY_MODEL}"
-            )
-            ru_sent_description = gr.Markdown(
-                value=f"Model for Sentiment: {RU_SENTIMENT_MODEL}"
-            )
-            ru_inputs = gr.Textbox(
-                label="ru_input",
-                lines=5,
-                value=DEFAULT_RU_TEXT,
-                placeholder=DEFAULT_RU_TEXT,
-            )
-            ru_lang = gr.Textbox(value="ru", visible=False)
-            ru_outputs = gr.Textbox(
-                label="ru_output",
-                lines=5,
-                placeholder="Здесь будет обобщение и эмоциональный окрас текста...",
-            )
-            ru_inbtn = gr.Button("Запустить")
-
-    en_inbtn.click(
-        pipe.summ,
+    with gr.Column(scale=2, min_width=600):
+        en_sum_description = gr.Markdown(value=f"Model for Summary: {EN_SUMMARY_MODEL}")
+        en_sent_description = gr.Markdown(
+            value=f"Model for Sentiment: {EN_SENTIMENT_MODEL}"
+        )
+        verify_href = gr.Markdown(
+            value="Available only for verified users.[Click here for verification.](/verify_page)"
+        )
+        en_inputs = gr.Textbox(
+            label="Input",
+            lines=5,
+            value=DEFAULT_EN_TEXT,
+            placeholder=DEFAULT_EN_TEXT,
+        )
+        # en_lang = gr.Textbox(value="en", visible=False)
+        en_lang = gr.Radio(["en", "ru"], value="en", label="Language")
+        en_outputs = gr.Textbox(
+            label="Output",
+            lines=5,
+            placeholder="Summary and Sentiment would be here...",
+        )
+        en_inbtn = gr.Button("Proceed")
+
+    en_inbtn = en_inbtn.click(
+        get_summary,
         [en_inputs, en_lang],
         [en_outputs],
     )
-    ru_inbtn.click(
-        pipe.summ,
-        [ru_inputs, ru_lang],
-        [ru_outputs],
-    )
 
+# demo.launch(server_name="127.0.0.1", server_port=8080, share=False)
 # mounting at the root path
 app = gr.mount_gradio_app(app, demo, path="/index")

models/exceptions.py

@@ -0,0 +1,18 @@
+from fastapi import Request
+from fastapi.exceptions import HTTPException
+from fastapi.templating import Jinja2Templates
+
+
+templates = Jinja2Templates(directory="templates")
+
+
+class MyHTTPException(HTTPException):
+    pass
+
+
+def my_http_exception_handler(request: Request, exc: HTTPException):
+    return templates.TemplateResponse(
+        "errors/error.html",
+        {"request": request, "message": f"{exc.status_code}. {exc.detail}."},
+        status_code=exc.status_code,
+    )

models/security.py

@@ -0,0 +1,99 @@
+import os
+import secrets
+from typing import Annotated
+from fastapi.security import HTTPBasic, HTTPBasicCredentials
+from fastapi import status, Depends, Cookie
+from datetime import datetime, timedelta
+from collections import defaultdict
+from loguru import logger
+from dotenv import load_dotenv
+
+from models.exceptions import MyHTTPException
+
+load_dotenv()
+
+API_USER = os.getenv("API_USER")
+API_PWD = os.getenv("API_PWD")
+API_KEY = os.getenv("API_KEY")
+
+security = HTTPBasic()
+
+
+class AuthUsers:
+    REQUESTS_LIMIT = 3  # 3 REQUESTS PER MINUTE
+    AUTH_TIME = 10  # 10 MINUTES
+    users: set
+    users_auth: defaultdict(list)
+
+    def __init__(self):
+        self.users = set()
+        self.users_auth = defaultdict(list)
+
+    def generate_user_token(self) -> str:
+        return secrets.token_hex(16)
+
+    def verify_user(self, user_token: str) -> bool:
+        logger.info(f"Check user token: {user_token}")
+        if user_token in self.users:
+            print(self.users_auth[user_token])
+            if len(self.users_auth[user_token]) < self.REQUESTS_LIMIT:
+                return True
+            elif datetime.now() - self.users_auth[user_token][
+                -self.REQUESTS_LIMIT
+            ] >= timedelta(minutes=self.AUTH_TIME):
+                return True
+            else:
+                raise MyHTTPException(
+                    status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+                    detail="Too many requests. Try again later.",
+                )
+        logger.info(f"User {user_token} not found")
+        raise MyHTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Unauthorized user",
+        )
+
+    def add_user_session(self, user_token: str):
+        if user_token in self.users:
+            self.users_auth[user_token].append(datetime.now())
+        else:
+            self.users.add(user_token)
+            self.users_auth.setdefault(user_token, []).append(datetime.now())
+            print(self.users_auth[user_token])
+            while len(self.users_auth[user_token]) > self.REQUESTS_LIMIT:
+                self.users_auth[user_token].pop(0)
+        logger.info(f"User's {user_token} session added")
+
+    def get_cookie_data(
+        self, user_token: str = Cookie(default=None, alias="Authorization")
+    ) -> list:
+        if not user_token or user_token not in self.users:
+            logger.info("Unauthorized user")
+            return False
+        logger.info(f"Verified user with token: {user_token}")
+        return True
+
+
+credentials_exception = MyHTTPException(
+    status_code=status.HTTP_401_UNAUTHORIZED,
+    detail="Login or password is incorrect",
+    headers={"WWW-Authenticate": "Basic"},
+)
+
+
+def check_api_credentials(
+    credentials: Annotated[HTTPBasicCredentials, Depends(security)]
+):
+    current_username_bytes = credentials.username.encode("utf8")
+    correct_username_bytes = bytes(API_USER, "utf-8")
+    is_correct_username = secrets.compare_digest(
+        current_username_bytes, correct_username_bytes
+    )
+    current_password_bytes = credentials.password.encode("utf8")
+    correct_password_bytes = bytes(API_PWD, "utf-8")
+    is_correct_password = secrets.compare_digest(
+        current_password_bytes, correct_password_bytes
+    )
+    if not (is_correct_username and is_correct_password):
+        raise credentials_exception
+    return credentials.username

pyproject.toml

@@ -10,7 +10,7 @@ readme = "README.md"
 python = "^3.10"
 transformers = "^4.36.2"
 gradio = "^4.11.0"
-torch = "1.13.1"
+torch = "^2.2.0"
 pydantic = "^2.5.3"
 pretrainedmodels = "^0.7.4"
 sentencepiece = "^0.1.99"
@@ -21,6 +21,8 @@ uvicorn = "^0.27.0"
 python-dotenv = "^1.0.1"
 jinja2 = "^3.1.3"
 aiohttp = "^3.9.3"
+bcrypt = "^4.1.2"
+passlib = "^1.7.4"
 
 
 [tool.poetry.group.dev.dependencies]

templates/bad_request.html

@@ -1,13 +0,0 @@
-{% extends "components/_base.html" %}
-
-{% block page_content %}
-<title> Bad Request </title>
-<meta name="description" content="">
-
-<!-- <h1>Sorry, your request not allowed</h1> -->
-<section class="bg-dark text-white pt-4 pb-5">
-    <div class="justify-content-center">
-        <h1 class="text-primary">Bad Request</h1>
-    </div>
-</section>
-{% endblock %}

templates/verification_old.html

@@ -1,50 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <meta http-equiv="X-UA-Compatible" content="ie=edge">
-    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.2.2/dist/css/bootstrap.min.css"/>
-    <link rel="stylesheet" href="{{ url_for('static',path='/css/style.css')}}"/> 
-    <script async src="https://www.google.com/recaptcha/api.js"></script>
-    <script>
-      function onSubmit(token) {
-        document.getElementById("verify_form").submit();
-      }
-    </script>
-    <script>
-      function onClick() {
-        grecaptcha.ready(function() {
-          grecaptcha.execute('{{ site_key }}', {action: 'submit'}).then(function(token) {
-              // Add your logic to submit to your backend server here.
-          });
-        });
-      }
-    </script>
-    <title>Verification Page</title>
-  </head>
-  <body>
-    <div class="row justify-content-center col-md-4">
-      <div class="align-self-center">
-        <h1 class="text-primary">Verification Page</h1>
-        <form id="verify_form" action="{{ url_for('verify') }}" method="post">
-          <div class="form-group my-3">
-            <input type="text" class="form-control" name="captcha" placeholder="Type captcha">
-          </div>
-          <!-- <button type="submit" class="btn btn-primary">Submit</button> -->
-
-          <!-- reCaptcha v3 -->
-          <button type="submit" class="g-recaptcha btn btn-primary" 
-            data-sitekey="{{ site_key }}" data-callback="onSubmit" 
-            data-action="submit">Submit
-          </button>
-          <!-- reCaptcha v2 -->
-          <!-- <div class="g-recaptcha" data-sitekey="{{ site_key }}"></div> -->
-          <!-- <div id="html_element"></div> -->
-          <!-- <button type="submit" class="btn btn-primary" onclick='onClick()'>Submit</button> -->
-        </form>
-      </div>
-    </div>
-    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.2.2/dist/css/bootstrap.min.css"></script>
-  </body>
-</html>