265 lines
8.5 KiB
Python
265 lines
8.5 KiB
Python
from datetime import timedelta, timezone, datetime
|
|
import io
|
|
from typing import Annotated
|
|
import base64
|
|
from fastapi import APIRouter, Depends, HTTPException, status
|
|
from fastapi.responses import JSONResponse
|
|
from pydantic import BaseModel, Field
|
|
import jwt
|
|
from jwt.exceptions import InvalidTokenError
|
|
from sqlmodel import Session, func, select
|
|
from sqlmodel.sql.expression import SelectOfScalar
|
|
from db import Chemistry, Player, engine, User
|
|
import networkx as nx
|
|
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
|
|
from pydantic_settings import BaseSettings, SettingsConfigDict
|
|
from passlib.context import CryptContext
|
|
import matplotlib
|
|
|
|
matplotlib.use("agg")
|
|
import matplotlib.pyplot as plt
|
|
|
|
|
|
class Config(BaseSettings):
|
|
secret_key: str = ""
|
|
access_token_expire_minutes: int = 30
|
|
model_config = SettingsConfigDict(
|
|
env_file=".env", env_file_encoding="utf-8", extra="ignore"
|
|
)
|
|
|
|
|
|
config = Config()
|
|
|
|
|
|
class Token(BaseModel):
|
|
access_token: str
|
|
token_type: str
|
|
|
|
|
|
class TokenData(BaseModel):
|
|
username: str | None = None
|
|
|
|
|
|
pwd_context = CryptContext(schemes=["argon2"], deprecated="auto")
|
|
|
|
|
|
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
|
|
|
|
analysis_router = APIRouter(prefix="/analysis", dependencies=[Depends(oauth2_scheme)])
|
|
|
|
|
|
def verify_password(plain_password, hashed_password):
|
|
return pwd_context.verify(plain_password, hashed_password)
|
|
|
|
|
|
def get_password_hash(password):
|
|
return pwd_context.hash(password)
|
|
|
|
|
|
def get_user(username: str):
|
|
with Session(engine) as session:
|
|
return session.exec(select(User).where(User.username == username)).one_or_none()
|
|
|
|
|
|
def authenticate_user(username: str, password: str):
|
|
user = get_user(username)
|
|
if not user:
|
|
return False
|
|
if not verify_password(password, user.hashed_password):
|
|
return False
|
|
return user
|
|
|
|
|
|
def create_access_token(data: dict, expires_delta: timedelta | None = None):
|
|
to_encode = data.copy()
|
|
if expires_delta:
|
|
expire = datetime.now(timezone.utc) + expires_delta
|
|
else:
|
|
expire = datetime.now(timezone.utc) + timedelta(minutes=15)
|
|
to_encode.update({"exp": expire})
|
|
encoded_jwt = jwt.encode(to_encode, config.secret_key, algorithm="HS256")
|
|
return encoded_jwt
|
|
|
|
|
|
async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]):
|
|
credentials_exception = HTTPException(
|
|
status_code=status.HTTP_401_UNAUTHORIZED,
|
|
detail="Could not validate credentials",
|
|
headers={"WWW-Authenticate": "Bearer"},
|
|
)
|
|
try:
|
|
payload = jwt.decode(token, config.secret_key, algorithms=["HS256"])
|
|
username: str = payload.get("sub")
|
|
if username is None:
|
|
raise credentials_exception
|
|
token_data = TokenData(username=username)
|
|
except InvalidTokenError:
|
|
raise credentials_exception
|
|
user = get_user(fake_users_db, username=token_data.username)
|
|
if user is None:
|
|
raise credentials_exception
|
|
return user
|
|
|
|
|
|
async def get_current_active_user(
|
|
current_user: Annotated[User, Depends(get_current_user)],
|
|
):
|
|
if current_user.disabled:
|
|
raise HTTPException(status_code=400, detail="Inactive user")
|
|
return current_user
|
|
|
|
|
|
@analysis_router.post("/token")
|
|
async def login_for_access_token(
|
|
form_data: Annotated[OAuth2PasswordRequestForm, Depends()],
|
|
) -> Token:
|
|
user = authenticate_user(form_data.username, form_data.password)
|
|
if not user:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_401_UNAUTHORIZED,
|
|
detail="Incorrect username or password",
|
|
headers={"WWW-Authenticate": "Bearer"},
|
|
)
|
|
access_token_expires = timedelta(minutes=config.access_token_expire_minutes)
|
|
access_token = create_access_token(
|
|
data={"sub": user.username}, expires_delta=access_token_expires
|
|
)
|
|
return Token(access_token=access_token, token_type="bearer")
|
|
|
|
|
|
C = Chemistry
|
|
P = Player
|
|
|
|
|
|
def sociogram_json():
|
|
nodes = []
|
|
necessary_nodes = set()
|
|
links = []
|
|
with Session(engine) as session:
|
|
for p in session.exec(select(P)).fetchall():
|
|
nodes.append({"id": p.name, "appearance": 1})
|
|
subquery = (
|
|
select(C.user, func.max(C.time).label("latest"))
|
|
.where(C.time > datetime(2025, 2, 1, 10))
|
|
.group_by(C.user)
|
|
.subquery()
|
|
)
|
|
statement2 = select(C).join(
|
|
subquery, (C.user == subquery.c.user) & (C.time == subquery.c.latest)
|
|
)
|
|
for c in session.exec(statement2):
|
|
# G.add_node(c.user)
|
|
necessary_nodes.add(c.user)
|
|
for p in c.love:
|
|
# G.add_edge(c.user, p)
|
|
# p_id = session.exec(select(P.id).where(P.name == p)).one()
|
|
necessary_nodes.add(p)
|
|
links.append({"source": c.user, "target": p})
|
|
# nodes = [n for n in nodes if n["name"] in necessary_nodes]
|
|
return JSONResponse({"nodes": nodes, "links": links})
|
|
|
|
|
|
def sociogram_data(show: int | None = 2):
|
|
G = nx.DiGraph()
|
|
with Session(engine) as session:
|
|
for p in session.exec(select(P)).fetchall():
|
|
G.add_node(p.name)
|
|
subquery = (
|
|
select(C.user, func.max(C.time).label("latest"))
|
|
.where(C.time > datetime(2025, 2, 1, 10))
|
|
.group_by(C.user)
|
|
.subquery()
|
|
)
|
|
statement2 = (
|
|
select(C)
|
|
# .where(C.user.in_(["Kruse", "Franz", "ck"]))
|
|
.join(subquery, (C.user == subquery.c.user) & (C.time == subquery.c.latest))
|
|
)
|
|
for c in session.exec(statement2):
|
|
if show >= 1:
|
|
for i, p in enumerate(c.love):
|
|
G.add_edge(c.user, p, group="love", rank=i, popularity=1 - 0.08 * i)
|
|
if show <= 1:
|
|
for i, p in enumerate(c.hate):
|
|
G.add_edge(c.user, p, group="hate", rank=8, popularity=-0.16)
|
|
return G
|
|
|
|
|
|
class Params(BaseModel):
|
|
node_size: int | None = Field(default=2400, alias="nodeSize")
|
|
font_size: int | None = Field(default=10, alias="fontSize")
|
|
arrow_size: int | None = Field(default=20, alias="arrowSize")
|
|
edge_width: float | None = Field(default=1, alias="edgeWidth")
|
|
distance: float | None = 0.2
|
|
weighting: bool | None = True
|
|
popularity: bool | None = True
|
|
show: int | None = 2
|
|
|
|
|
|
ARROWSTYLE = {"love": "-|>", "hate": "-|>"}
|
|
EDGESTYLE = {"love": "-", "hate": ":"}
|
|
EDGECOLOR = {"love": "#404040", "hate": "#cc0000"}
|
|
|
|
|
|
async def render_sociogram(params: Params):
|
|
plt.figure(figsize=(16, 10), facecolor="none")
|
|
ax = plt.gca()
|
|
ax.set_facecolor("none") # Set the axis face color to none (transparent)
|
|
ax.axis("off") # Turn off axis ticks and frames
|
|
|
|
G = sociogram_data(show=params.show)
|
|
pos = nx.spring_layout(G, scale=2, k=params.distance, iterations=50, seed=None)
|
|
nodes = nx.draw_networkx_nodes(
|
|
G,
|
|
pos,
|
|
node_color=[
|
|
v for k, v in G.in_degree(weight="popularity" if params.weighting else None)
|
|
]
|
|
if params.popularity
|
|
else "#99ccff",
|
|
edgecolors="#404040",
|
|
linewidths=0,
|
|
# node_shape="8",
|
|
node_size=params.node_size,
|
|
cmap="coolwarm",
|
|
alpha=0.86,
|
|
)
|
|
if params.popularity:
|
|
cbar = plt.colorbar(nodes)
|
|
cbar.ax.set_xlabel("popularity")
|
|
nx.draw_networkx_labels(G, pos, font_size=params.font_size)
|
|
nx.draw_networkx_edges(
|
|
G,
|
|
pos,
|
|
arrows=True,
|
|
edge_color=[EDGECOLOR[G.edges()[*edge]["group"]] for edge in G.edges()],
|
|
arrowsize=params.arrow_size,
|
|
node_size=params.node_size,
|
|
width=params.edge_width,
|
|
style=[EDGESTYLE[G.edges()[*edge]["group"]] for edge in G.edges()],
|
|
arrowstyle=[ARROWSTYLE[G.edges()[*edge]["group"]] for edge in G.edges()],
|
|
connectionstyle="arc3,rad=0.12",
|
|
alpha=[1 - 0.08 * G.edges()[*edge]["rank"] for edge in G.edges()]
|
|
if params.weighting
|
|
else 1,
|
|
)
|
|
|
|
buf = io.BytesIO()
|
|
plt.savefig(buf, format="png", bbox_inches="tight", dpi=300, transparent=True)
|
|
buf.seek(0)
|
|
encoded_image = base64.b64encode(buf.read()).decode("UTF-8")
|
|
plt.close()
|
|
|
|
return {"image": encoded_image}
|
|
|
|
|
|
analysis_router.add_api_route("/json", endpoint=sociogram_json, methods=["GET"])
|
|
analysis_router.add_api_route("/image", endpoint=render_sociogram, methods=["POST"])
|
|
|
|
if __name__ == "__main__":
|
|
with Session(engine) as session:
|
|
statement: SelectOfScalar[P] = select(func.count(P.id))
|
|
print("players in DB: ", session.exec(statement).first())
|
|
G = sociogram_data()
|
|
pos = nx.spring_layout(G, scale=1, k=2, iterations=50, seed=42)
|