dev step

main.py

@@ -4,7 +4,7 @@ from fastapi.security import HTTPBasic, HTTPBasicCredentials
 import os, json
 import time
 from hashlib import sha256
-from modules import model, oauth, security, log_module, llm, token_counter, chat_functions
+from modules import model, oauth, security, log_module, llm, chat_functions, settings
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from datetime import datetime 
@@ -14,8 +14,6 @@ app = FastAPI(docs_url=None, redoc_url=None)
 app.mount("/static", StaticFiles(directory="static"), name="static")
 templates = Jinja2Templates(directory="templates")
 
-users = json.loads(str(os.getenv("USER_KEYS")).replace("\n", ""))
-
 fecha_unix = str(int(time.time()))
 log_module.log_write("master", "iniciado", "-")
 
@@ -41,7 +39,7 @@ async def main_page(request: Request, user = Depends(model.User.find_from_cookie
 ########################## SECURITY ##########################
 @app.get("/login", response_class=HTMLResponse)
 async def login(request: Request):
-    ret = templates.TemplateResponse("iniciar_sesion.html", {"request": request, "redirecturi": oauth.OAUTH_REDIRECT})
+    ret = templates.TemplateResponse("iniciar_sesion.html", {"request": request, "redirecturi": settings.OAUTH_REDIRECT})
     ret.delete_cookie("token")
     return ret
 

modules/llm.py

@@ -3,19 +3,19 @@ import os, json, time
 from hashlib import sha256
 from fastapi import HTTPException
 from openai import OpenAI
+import tiktoken
 
-
-from . import log_module, error_map, chat_functions as tools
+from . import log_module, error_map, chat_functions as tools, settings
 from typing import TYPE_CHECKING                
 if TYPE_CHECKING:                               
     from . import model
 
 
-OPENAI_API_KEY=os.environ['OPENAI_API_KEY']
 
-gptmodel = "gpt-3.5-turbo-1106"
 
-encoding = tiktoken.encoding_for_model(llm.gptmodel)
+
+
+encoding = tiktoken.encoding_for_model(settings.GPT_MODEL)
 
 
 def ejecutar(body: "model.Body", user: "model.User"):
@@ -23,12 +23,12 @@ def ejecutar(body: "model.Body", user: "model.User"):
      
     try:
         client = OpenAI(
-            api_key=OPENAI_API_KEY,  
+            api_key=settings.OPENAI_API_KEY,  
             timeout=30.0,
             max_retries=3
             )
         generated = client.chat.completions.create(
-            model=gptmodel,
+            model=settings.GPT_MODEL,
             messages=temp_messages,
             temperature=user.configs.temperature,
             frequency_penalty=user.configs.frequency_penalty,

modules/model.py

@@ -2,24 +2,23 @@ import os
 from pymongo.mongo_client import MongoClient
 from pymongo.server_api import ServerApi
 from fastapi import Request
-from . import log_module, security, token_counter
+from . import log_module, security, settings
 from datetime import timezone, datetime, timedelta
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from typing import List, Dict
 import tiktoken
+import uuid
+from typing import Annotated
 
 
-MONGO_URL = os.environ.get("MONGO_URL", None)
-MONGO_PWD = os.environ.get("MONGO_PWD", None)
-MONGO_USR = os.environ.get("MONGO_USR", None)
-#uri = f"mongodb+srv://{MONGO_USR}:{MONGO_PWD}@{MONGO_URL}/?retryWrites=true&w=majority"
-uri = "mongodb://localhost:27017"
-client = MongoClient(uri, server_api=ServerApi('1'))
-user_table = client.ChatDB.users
-sess_table = client.ChatDB.sessions
+client = MongoClient(settings.DB_URI, server_api=ServerApi('1'))
+class __DB:
+    user = client.ChatDB.users
+    sess = client.ChatDB.sessions
+DB = __DB()
 
 tz = timezone(timedelta(hours=-4))
-
+encoding = tiktoken.encoding_for_model(settings.GPT_MODEL)
 
 def count_tokens_on_message(args):
     token_count = 0
@@ -61,13 +60,37 @@ class Chat(BaseModel):
     def new_msg(self):
         return Message(role="", content="")
 
-class SecToken(BaseModel):
-    actual: str = ""
-    prev: str = ""
+class Session(BaseModel):
+    gid: str
+    guid: str = str(uuid.uuid4())
+    created: datetime = datetime.now(tz)
+    updated: datetime = datetime.now(tz)
+    expire: datetime =  datetime.now(tz)+timedelta(days=7)
+
+    @classmethod
+    def find(cls, gid: str, guid: str):
+        sess = DB.sess.find_one({"gid": gid, "guid": guid})
+        if sess.expire < datetime.now(tz):
+            DB.sess.find_one_and_delete({"gid": gid, "guid": guid})
+            return False
+    
+        sess.update = datetime.now(tz)
+        sess.expire = datetime.now(tz)+timedelta(days=7)
+
+        DB.sess.update_one({"gid": gid, "guid": guid}, {"$set": sess.model_dump()})
+        
+        return guid
+    
+    @classmethod
+    def create(cls, gid: str):
+        temp = cls(gid=gid)
+        DB.sess.insert_one(temp.model_dump())    
+        return temp
 
+    
 class User(BaseModel):
     name: str
-    gptTokens: dict = {}
+    tokens: dict = {}
     created: datetime = datetime.now(tz)
     approved: datetime | None = None
     description: str = ""
@@ -75,19 +98,35 @@ class User(BaseModel):
     gid: str
     role: str = "on hold"
     configs: Configs = Configs()
-    viewToken: SecToken = SecToken() 
-    apiToken: SecToken = SecToken()
+    session: Session | None = None
 
     @classmethod
     def find(cls, gid: str):
-        found = user_table.find_one({"gid":gid})
+        found = DB.user.find_one({"gid":gid})
         if found:
             return cls(**found)
         return None
+    
+    @classmethod
+    def find_or_create(cls, data: dict):
+        sess = Session.create(data["gid"]) 
+        found = cls.find(data["gid"])
+        if found:
+            found.session = sess
+            return found
+        user = User(**data)
+        user.session = sess
+        
+        DB.user.insert_one(user.model_dump(exclude={"session"}))  
+        log_module.logger.info(f"User created: {user.gid}")
+        return user
+    
 
     @classmethod
     def find_from_header(cls, request: Request):
-        return cls.find_from_token(request, "api")
+        temp = cls.find_from_token(request, "api")
+
+        return temp
 
     @classmethod
     def find_from_cookie(cls, request: Request):
@@ -96,49 +135,35 @@ class User(BaseModel):
     @classmethod
     def find_from_token(cls, request: Request, usage: str):
         data = None
-        token_type = None
         if usage=="view":
             data = security.token_from_cookie(request)
-            token_type = "viewToken"
         else:
             data = security.token_from_headers(request)
-            token_type = "apiToken"
-        
-        if data.pop("usage") != usage:
-            log_module.logger.error(f"Bad usage - Invalid token: for usage {usage}")
-            return security.raise_401()
         
-        token_string = data.pop("token_string", "")
+        user = DB.user.find_one({"gid":data["gid"]})
 
-        user = user_table.find_one({"gid":data["gid"], f"{token_type}.actual":token_string})
-        if not user:
+        if user:
+            sess = Session.find(user.gid, data["guid"])
+
+        if not user or not sess:
             security.raise_307()
-        return cls(**user)
+        user = cls(**user)
+        user.session = sess
+        return user
         
         
-    @classmethod
-    def find_or_create(cls, data: dict):
-        found = cls.find(data["gid"])
-        if found:
-            return found
-        user = User(**data)
-        user_table.insert_one(user.model_dump())    
-        log_module.logger.info(f"User created: {user.gid}")
-        return user
     
     def create_token(self, usage: str):
-        token = security.create_jwt_token({"gid": self.gid, "usage":usage}, usage)
+        token = security.create_jwt_token({"gid": self.gid, "usage":usage, "guid": self.session.guid}, usage)
         if usage=="view":
-            self.viewToken.prev = self.viewToken.actual
-            self.viewToken.actual = token
+            pass
         else:
-            self.apiToken.prev = self.apiToken.actual
-            self.apiToken.actual = token
+            pass
         return token
     
     def update_description(self, message):
         log_module.logger.info(f"Description Updated: {self.gid}")
-        user_table.update_one(
+        DB.user.update_one(
             {"gid":self.gid}, 
             {"$set": { "description": message}}
         )
@@ -153,23 +178,19 @@ class User(BaseModel):
             count_tokens = message.tokensOutput+message.tokensPrompt
         now = datetime.now()
         
-        if str(now.year) not in self.gptTokens:
-            self.gptTokens[str(now.year)] = {}
+        if str(now.year) not in self.tokens:
+            self.tokens[str(now.year)] = {}
 
-        if str(now.month) not in self.gptTokens[str(now.year)]:
-            self.gptTokens[str(now.year)][str(now.month)] = {}
+        if str(now.month) not in self.tokens[str(now.year)]:
+            self.tokens[str(now.year)][str(now.month)] = {}
         
-        if str(now.day) not in self.gptTokens[str(now.year)][str(now.month)] :
-            self.gptTokens[str(now.year)][str(now.month)][str(now.day)] = 0
+        if str(now.day) not in self.tokens[str(now.year)][str(now.month)] :
+            self.tokens[str(now.year)][str(now.month)][str(now.day)] = 0
             
-        self.gptTokens[str(now.year)][str(now.month)][str(now.day)] += count_tokens
+        self.tokens[str(now.year)][str(now.month)][str(now.day)] += count_tokens
 
-        user_table.update_one({"gid": self.gid}, {"$set": self.model_dump()})
+        DB.user.update_one({"gid": self.gid}, {"$set": self.model_dump(exclude={"guid", "session"})})
+
+
+    
 
-class Session:
-    user: str
-    m
-    guid: str
-    created: datetime = datetime.now(tz)
-    updated: datetime
-    expire: datetime

modules/oauth.py

@@ -1,16 +1,12 @@
 import requests, os
-
-
-GOOGLE_CLIENT_ID = os.environ.get("GOOGLE_CLIENT_ID", None)
-GOOGLE_CLIENT_SECRET = os.environ.get("GOOGLE_CLIENT_SECRET", None)
-OAUTH_REDIRECT = os.environ.get("OAUTH_REDIRECT", None)
+from . import settings
 
 def validate_redirect(params):
     data = {
         'code': params["code"],
-        'redirect_uri': OAUTH_REDIRECT,
-        'client_id': GOOGLE_CLIENT_ID,
-        'client_secret': GOOGLE_CLIENT_SECRET,
+        'redirect_uri': settings.OAUTH_REDIRECT,
+        'client_id': settings.GOOGLE_CLIENT_ID,
+        'client_secret': settings.GOOGLE_CLIENT_SECRET,
         'scope': params["scope"],
         'grant_type': 'authorization_code'
     }
@@ -26,7 +22,7 @@ def validate_redirect(params):
         print(e)
         print(google_auth_rq.content)
         return str(e)+" "+google_auth_rq.content
-    google_userinfo_rq = requests.get("https://www.googleapis.com/oauth2/v2/userinfo", headers=headers, timeout=5)
+    google_userinfo_rq = requests.get("https://www.googleapis.com/oauth2/v2/userinfo", headers=headers, timeout=30)
     ret = google_userinfo_rq.json()
     ret["gid"] = ret.get("id","")
     return ret

modules/security.py

@@ -3,37 +3,34 @@ from hashlib import sha256
 from fastapi import HTTPException, status, Request
 from fastapi.security import HTTPBasicCredentials
 from fastapi.responses import RedirectResponse
-from . import log_module
-from datetime import datetime, timedelta
+from . import log_module, settings
+from datetime import datetime, timedelta    
 
 
-users = json.loads(str(os.getenv("USER_KEYS")).replace("\n", ""))
-for key in users:
+
+for key in settings.USERS:
     if key == "master": continue
-    password = key+users[key]+users["master"]
-    users[key] = sha256(password.encode('UTF-8')).hexdigest()
+    password = key+settings.USERS[key]+settings.USERS["master"]
+    settings.USERS[key] = sha256(password.encode('UTF-8')).hexdigest()
+
 
-JWT_SECRET = users["master"]
-JWT_ALGORITHM = "HS256"
-JWT_EXPIRATION_TIME_MINUTES_API = 30
-JWT_EXPIRATION_TIME_MINUTES_VIEW = 7*24*60
 
 
 def create_jwt_token(data, usage):
     to_encode = data
 
     if usage == "api":
-        expire = datetime.utcnow() + timedelta(minutes=JWT_EXPIRATION_TIME_MINUTES_API)
+        expire = datetime.utcnow() + timedelta(minutes=settings.JWT_EXPIRATION_TIME_MINUTES_API)
     elif usage == "view":
-        expire = datetime.utcnow() + timedelta(minutes=JWT_EXPIRATION_TIME_MINUTES_VIEW)
+        expire = datetime.utcnow() + timedelta(minutes=settings.JWT_EXPIRATION_TIME_MINUTES_VIEW)
         
     to_encode.update({"exp": expire})
-    encoded_jwt = jwt.encode(to_encode, JWT_SECRET, algorithm=JWT_ALGORITHM)
+    encoded_jwt = jwt.encode(to_encode, settings.JWT_SECRET, algorithm=settings.JWT_ALGORITHM)
     return encoded_jwt
 
 def validate_jwt_token(token: str, usage: str = "api"):
     try:
-        payload = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM])
+        payload = jwt.decode(token, settings.JWT_SECRET, algorithms=[settings.JWT_ALGORITHM])
         return payload
     except Exception as e: 
         log_module.logger.error(repr(e) + " - Invalid token: " + str(token))
@@ -43,12 +40,12 @@ def validate_jwt_token(token: str, usage: str = "api"):
 
 def token_from_cookie(request:Request):
     if token := request.cookies.get('token', ""):
-        return validate_jwt_token(token, "view") | {"token_string": token}
+        return validate_jwt_token(token, "view")
     return raise_307()
 
 def token_from_headers(request:Request):
     if (bearer := request.headers.get("Autorization", " ").split(" ",1)) and bearer[0] == "Bearer":
-        return validate_jwt_token(bearer[1]) | {"token_string": bearer[1]}
+        return validate_jwt_token(bearer[1])
     return raise_401()
     
 

modules/settings.py

@@ -0,0 +1,31 @@
+import os, json
+
+from datetime import timezone, datetime, timedelta
+from pymongo.mongo_client import MongoClient
+from pymongo.server_api import ServerApi
+
+
+TZ = timezone(timedelta(hours=-4))
+
+GPT_MODEL = "gpt-3.5-turbo-1106"
+
+MONGO_URL = os.environ.get("MONGO_URL", None)
+MONGO_PWD = os.environ.get("MONGO_PWD", None)
+MONGO_USR = os.environ.get("MONGO_USR", None)
+#DB_URI = f"mongodb+srv://{MONGO_USR}:{MONGO_PWD}@{MONGO_URL}/?retryWrites=true&w=majority"
+DB_URI = "mongodb://127.0.0.1:27017"
+
+OPENAI_API_KEY=os.environ.get('OPENAI_API_KEY')
+
+
+USERS = json.loads(str(os.getenv("USER_KEYS")).replace("\n", ""))
+
+JWT_SECRET = USERS["master"]
+JWT_ALGORITHM = "HS256"
+JWT_EXPIRATION_TIME_MINUTES_API = 30
+JWT_EXPIRATION_TIME_MINUTES_VIEW = 7*24*60
+
+
+GOOGLE_CLIENT_ID = os.environ.get("GOOGLE_CLIENT_ID")
+GOOGLE_CLIENT_SECRET = os.environ.get("GOOGLE_CLIENT_SECRET")
+OAUTH_REDIRECT = os.environ.get("OAUTH_REDIRECT")

static/js/fingerprint.js

@@ -1,101 +0,0 @@
-var codecs = ['application/ogg',
-'application/ogg; codecs=bogus',
-'application/mp4',
-'application/mp4; codecs=bogus',
-'application/octet-stream',
-'application/octet-stream; codecs=bogus',
-'audio/3gpp',
-'audio/3gpp2',
-'audio/aac',
-'audio/x-aac',
-'audio/aiff',
-'audio/x-aiff',
-'audio/ac3',
-'audio/x-ac3',
-'audio/basic',
-'audio/flac',
-'audio/x-flac',
-'audio/mid',
-'audio/midi',
-'audio/x-midi',
-'audio/mpeg',
-'audio/x-mpeg',
-'audio/mpegurl',
-'audio/x-mpegurl',
-'audio/mp4',
-'audio/mp4; codecs=bogus',
-'audio/ogg',
-'audio/ogg; codecs=bogus',
-'audio/wav',
-'audio/wav; codecs=0',
-'audio/wav; codecs=1',
-'audio/wav; codecs=2',
-'audio/wave',
-'audio/wave; codecs=0',
-'audio/wave; codecs=1',
-'audio/wave; codecs=2',
-'audio/x-wav',
-'audio/x-wav; codecs=0',
-'audio/x-wav; codecs=1',
-'audio/x-wav; codecs=2',
-'audio/x-pn-wav',
-'audio/x-pn-wav; codecs=0',
-'audio/x-pn-wav; codecs=1',
-'audio/x-pn-wav; codecs=2',
-'video/3gpp',
-'video/3gpp2',
-'video/avi',
-'video/mpeg',
-'video/x-mpeg',
-'video/mp4',
-'video/mp4; codecs=bogus',
-'video/msvideo',
-'video/x-msvideo',
-'video/quicktime',
-'video/ogg',
-'video/ogg; codecs=bogus',
-'video/mp4; codecs="avc1.42E01E, mp4a.40.2"',
-'video/mp4; codecs="avc1.58A01E, mp4a.40.2"',
-'video/mp4; codecs="avc1.4D401E, mp4a.40.2"',
-'video/mp4; codecs="avc1.64001E, mp4a.40.2"',
-'video/mp4; codecs="mp4v.20.8, mp4a.40.2"',
-'video/mp4; codecs="mp4v.20.240, mp4a.40.2"',
-'video/mp4; codecs="avc1.64001E, mp4a.40.2"',
-'video/mp4; codecs="mp4v.20.8, mp4a.40.2"',
-'video/mp4; codecs=hev1',
-'video/mp4; codecs=hev1.1.6.L93.B0',
-'video/mp4; codecs=hvc1',
-'video/mp4; codecs=hvc1.1.6.L93.B0',
-'video/mp4; codecs=av01',
-'video/mp4; codecs=av01.0.04M.08',
-'video/mp4; codecs="av01.0.04M.08, mp4a.40.2"',
-'video/mp4; codecs="av01.0.04M.08, opus"',
-'audio/mp4; codecs=mp4a.40.2',
-'audio/mp4; codecs=mp4a.40.02',
-'audio/mp4; codecs=mp4a.40.5',
-'audio/mp4; codecs=mp4a.40.05',
-'audio/mp4; codecs=mp4a.40.29',
-'audio/mp4; codecs=mp4a.40.42',
-'audio/mp4; codecs=opus',
-'video/3gpp; codecs="mp4v.20.8, samr"',
-'video/ogg; codecs="theora, vorbis"',
-'video/ogg; codecs="theora, speex"',
-'audio/ogg; codecs=vorbis',
-'audio/ogg; codecs=speex',
-'audio/ogg; codecs=flac',
-'audio/ogg; codecs=opus',
-'video/ogg; codecs="dirac, vorbis"',
-'video/x-matroska; codecs="theora, vorbis"',
-'audio/webm',
-'audio/webm; codecs=vorbis',
-'video/webm',
-'video/webm; codecs=vorbis',
-'video/webm; codecs=vp8',
-'video/webm; codecs=vp8.0',
-'video/webm; codecs="vp8, vorbis"',
-'video/webm; codecs=vp9',
-'video/webm; codecs=vp9.0',
-'video/webm; codecs=vp09',
-'video/webm; codecs=vp09.00.10.08']
-
-window.navigator.userAgent

token_counter.py

@@ -1,17 +0,0 @@
-import tiktoken
-def count_tokens(messages, model="gpt-3.5-turbo-16k"):
-    """Returns the number of tokens used by a list of messages."""
-    try:
-        encoding = tiktoken.encoding_for_model(model)
-    except KeyError:
-        encoding = tiktoken.get_encoding("cl100k_base")
-
-    num_tokens = 0
-    for message in messages:
-        num_tokens += 4  # every message follows <im_start>{role/name}\n{content}<im_end>\n
-        for key, value in message.items():
-            num_tokens += len(encoding.encode(value))
-            if key == "name":  # if there's a name, the role is omitted
-                num_tokens += -1  # role is always required and always 1 token
-    num_tokens += 2  # every reply is primed with <im_start>assistant
-    return num_tokens