Changed max line length for python

Author: Wunderwaffel

backend/app/core/security.py

@@ -1,62 +1,66 @@
-"""Security utilities for creating and validating JWT tokens."""
-
-from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, Optional
-
-from fastapi import Depends, HTTPException, status
-from fastapi.security import OAuth2PasswordBearer
-from jose import JWTError, jwt
-
-from app.core.config import settings
-
-ALGORITHM = "HS256"
-
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/login")
-
-
-def create_access_token(data: Dict[str, Any], expires_delta: Optional[timedelta] = None) -> str:
-    """Create a signed JWT access token."""
-
-    to_encode = data.copy()
-    expire = datetime.now(timezone.utc) + (expires_delta or timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES))
-    to_encode.update({"exp": expire})
-    return jwt.encode(to_encode, settings.JWT_SECRET_KEY, algorithm=ALGORITHM)
-
-
-def create_refresh_token(data: Dict[str, Any], expires_delta: Optional[timedelta] = None) -> str:
-    """Create a signed JWT refresh token."""
-
-    to_encode = data.copy()
-    expire = datetime.now(timezone.utc) + (expires_delta or timedelta(days=settings.REFRESH_TOKEN_EXPIRE_DAYS))
-    to_encode.update({"exp": expire, "type": "refresh"})
-    return jwt.encode(to_encode, settings.JWT_SECRET_KEY, algorithm=ALGORITHM)
-
-
-def verify_token(token: str) -> Optional[Dict[str, Any]]:
-    """Decode a JWT token and return its payload, if valid."""
-
-    try:
-        return jwt.decode(token, settings.JWT_SECRET_KEY, algorithms=[ALGORITHM])
-    except JWTError:
-        return None
-
-
-def get_current_user(token: str = Depends(oauth2_scheme)) -> str:
-    """Return the username encoded in the access token."""
-
-    payload = verify_token(token)
-    if not payload:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid or expired token.",
-            headers={"WWW-Authenticate": "Bearer"},
-        )
-
-    username = payload.get("sub")
-    if not username:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid token payload.",
-        )
-
-    return username
+"""Security utilities for creating and validating JWT tokens."""
+
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, Optional
+
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jose import JWTError, jwt
+
+from app.core.config import settings
+
+ALGORITHM = "HS256"
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/login")
+
+
+def create_access_token(data: Dict[str, Any], expires_delta: Optional[timedelta] = None) -> str:
+    """Create a signed JWT access token."""
+
+    to_encode = data.copy()
+    expire = datetime.now(timezone.utc) + (
+        expires_delta or timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    )
+    to_encode.update({"exp": expire})
+    return jwt.encode(to_encode, settings.JWT_SECRET_KEY, algorithm=ALGORITHM)
+
+
+def create_refresh_token(data: Dict[str, Any], expires_delta: Optional[timedelta] = None) -> str:
+    """Create a signed JWT refresh token."""
+
+    to_encode = data.copy()
+    expire = datetime.now(timezone.utc) + (
+        expires_delta or timedelta(days=settings.REFRESH_TOKEN_EXPIRE_DAYS)
+    )
+    to_encode.update({"exp": expire, "type": "refresh"})
+    return jwt.encode(to_encode, settings.JWT_SECRET_KEY, algorithm=ALGORITHM)
+
+
+def verify_token(token: str) -> Optional[Dict[str, Any]]:
+    """Decode a JWT token and return its payload, if valid."""
+
+    try:
+        return jwt.decode(token, settings.JWT_SECRET_KEY, algorithms=[ALGORITHM])
+    except JWTError:
+        return None
+
+
+def get_current_user(token: str = Depends(oauth2_scheme)) -> str:
+    """Return the username encoded in the access token."""
+
+    payload = verify_token(token)
+    if not payload:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or expired token.",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    username = payload.get("sub")
+    if not username:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid token payload.",
+        )
+
+    return username

backend/app/models/paper.py

@@ -1,45 +1,51 @@
-"""SQLAlchemy model and enumerations for scholarly papers."""
-
-from datetime import date, datetime
-from typing import TYPE_CHECKING, List, Optional
-
-from sqlalchemy import JSON, BigInteger, Date, DateTime, String, Text
-from sqlalchemy import Enum as SqlEnum
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-from sqlalchemy.sql import func
-
-from app.constants.database_constants import PaperSource, PaperType
-from app.core.database import Base
-
-
-class Paper(Base):
-    """Database representation of a scholarly paper."""
-
-    __tablename__ = "paper"
-
-    paper_id: Mapped[int] = mapped_column(BigInteger, primary_key=True, index=True)
-    doi: Mapped[str] = mapped_column(String(255), nullable=False, unique=True)
-    source: Mapped[PaperSource] = mapped_column(SqlEnum(PaperSource, name="paper_source"), nullable=False)
-    paper_type: Mapped[PaperType] = mapped_column(
-        SqlEnum(PaperType, name="paper_type"),
-        nullable=False,
-        default=PaperType.PREPRINT,
-        server_default=PaperType.PREPRINT.value,
-    )
-    title: Mapped[str] = mapped_column(String(512), nullable=False)
-    authors: Mapped[Optional[dict]] = mapped_column(JSON, nullable=True)
-    abstract: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
-    published_at: Mapped[Optional[date]] = mapped_column(Date, nullable=True)
-    pdf_url: Mapped[Optional[str]] = mapped_column(String(512), nullable=True)
-    url: Mapped[Optional[str]] = mapped_column(String(512), nullable=True)
-    fetched_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
-
-    project_links: Mapped[List["ProjectPaper"]] = relationship(
-        "ProjectPaper", back_populates="paper", cascade="all, delete-orphan"
-    )
-    projects: Mapped[List["Project"]] = relationship("Project", secondary="project_paper", back_populates="papers")
-
-
-if TYPE_CHECKING:
-    from .project import Project
-    from .project_paper import ProjectPaper
+"""SQLAlchemy model and enumerations for scholarly papers."""
+
+from datetime import date, datetime
+from typing import TYPE_CHECKING, List, Optional
+
+from sqlalchemy import JSON, BigInteger, Date, DateTime, String, Text
+from sqlalchemy import Enum as SqlEnum
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.sql import func
+
+from app.constants.database_constants import PaperSource, PaperType
+from app.core.database import Base
+
+
+class Paper(Base):
+    """Database representation of a scholarly paper."""
+
+    __tablename__ = "paper"
+
+    paper_id: Mapped[int] = mapped_column(BigInteger, primary_key=True, index=True)
+    doi: Mapped[str] = mapped_column(String(255), nullable=False, unique=True)
+    source: Mapped[PaperSource] = mapped_column(
+        SqlEnum(PaperSource, name="paper_source"), nullable=False
+    )
+    paper_type: Mapped[PaperType] = mapped_column(
+        SqlEnum(PaperType, name="paper_type"),
+        nullable=False,
+        default=PaperType.PREPRINT,
+        server_default=PaperType.PREPRINT.value,
+    )
+    title: Mapped[str] = mapped_column(String(512), nullable=False)
+    authors: Mapped[Optional[dict]] = mapped_column(JSON, nullable=True)
+    abstract: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    published_at: Mapped[Optional[date]] = mapped_column(Date, nullable=True)
+    pdf_url: Mapped[Optional[str]] = mapped_column(String(512), nullable=True)
+    url: Mapped[Optional[str]] = mapped_column(String(512), nullable=True)
+    fetched_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+    project_links: Mapped[List["ProjectPaper"]] = relationship(
+        "ProjectPaper", back_populates="paper", cascade="all, delete-orphan"
+    )
+    projects: Mapped[List["Project"]] = relationship(
+        "Project", secondary="project_paper", back_populates="papers"
+    )
+
+
+if TYPE_CHECKING:
+    from .project import Project
+    from .project_paper import ProjectPaper

backend/app/models/project.py

@@ -1,33 +1,39 @@
-"""SQLAlchemy model for projects managed in the application."""
-
-from datetime import datetime
-from typing import TYPE_CHECKING, List
-
-from sqlalchemy import BigInteger, DateTime, ForeignKey, String
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-from sqlalchemy.sql import func
-
-from app.core.database import Base
-
-
-class Project(Base):
-    """Database representation of a user project."""
-
-    __tablename__ = "project"
-
-    project_id: Mapped[int] = mapped_column(BigInteger, primary_key=True, index=True)
-    created_by: Mapped[int] = mapped_column(BigInteger, ForeignKey("user.user_id"), nullable=False, index=True)
-    project_name: Mapped[str] = mapped_column(String(255), nullable=False)
-    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
-
-    creator: Mapped["User"] = relationship("User", back_populates="projects")
-    project_papers: Mapped[List["ProjectPaper"]] = relationship(
-        "ProjectPaper", back_populates="project", cascade="all, delete-orphan"
-    )
-    papers: Mapped[List["Paper"]] = relationship("Paper", secondary="project_paper", back_populates="projects")
-
-
-if TYPE_CHECKING:
-    from .paper import Paper
-    from .project_paper import ProjectPaper
-    from .user import User
+"""SQLAlchemy model for projects managed in the application."""
+
+from datetime import datetime
+from typing import TYPE_CHECKING, List
+
+from sqlalchemy import BigInteger, DateTime, ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.sql import func
+
+from app.core.database import Base
+
+
+class Project(Base):
+    """Database representation of a user project."""
+
+    __tablename__ = "project"
+
+    project_id: Mapped[int] = mapped_column(BigInteger, primary_key=True, index=True)
+    created_by: Mapped[int] = mapped_column(
+        BigInteger, ForeignKey("user.user_id"), nullable=False, index=True
+    )
+    project_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+
+    creator: Mapped["User"] = relationship("User", back_populates="projects")
+    project_papers: Mapped[List["ProjectPaper"]] = relationship(
+        "ProjectPaper", back_populates="project", cascade="all, delete-orphan"
+    )
+    papers: Mapped[List["Paper"]] = relationship(
+        "Paper", secondary="project_paper", back_populates="projects"
+    )
+
+
+if TYPE_CHECKING:
+    from .paper import Paper
+    from .project_paper import ProjectPaper
+    from .user import User

backend/app/models/project_paper.py

@@ -1,45 +1,49 @@
-"""Association table model linking projects and papers."""
-
-from datetime import datetime
-from typing import TYPE_CHECKING
-
-from sqlalchemy import BigInteger, DateTime, ForeignKey, UniqueConstraint
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-from sqlalchemy.sql import func
-
-from app.core.database import Base
-
-
-class ProjectPaper(Base):
-    """Associative entity connecting projects with papers."""
-
-    __tablename__ = "project_paper"
-
-    # Ensure a paper can only be linked once to the same project.
-    __table_args__ = (
-        UniqueConstraint(
-            "project_id",
-            "paper_id",
-            name="uq_project_paper_project_id_paper_id",
-        ),
-    )
-
-    project_paper_id: Mapped[int] = mapped_column(BigInteger, primary_key=True, index=True)
-
-    project_id: Mapped[int] = mapped_column(BigInteger, ForeignKey("project.project_id"), nullable=False, index=True)
-
-    paper_id: Mapped[int] = mapped_column(BigInteger, ForeignKey("paper.paper_id"), nullable=False, index=True)
-
-    added_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True),
-        nullable=False,
-        server_default=func.now(),
-    )
-
-    project: Mapped["Project"] = relationship("Project", back_populates="project_papers")
-    paper: Mapped["Paper"] = relationship("Paper", back_populates="project_links")
-
-
-if TYPE_CHECKING:
-    from .paper import Paper
-    from .project import Project
+"""Association table model linking projects and papers."""
+
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from sqlalchemy import BigInteger, DateTime, ForeignKey, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.sql import func
+
+from app.core.database import Base
+
+
+class ProjectPaper(Base):
+    """Associative entity connecting projects with papers."""
+
+    __tablename__ = "project_paper"
+
+    # Ensure a paper can only be linked once to the same project.
+    __table_args__ = (
+        UniqueConstraint(
+            "project_id",
+            "paper_id",
+            name="uq_project_paper_project_id_paper_id",
+        ),
+    )
+
+    project_paper_id: Mapped[int] = mapped_column(BigInteger, primary_key=True, index=True)
+
+    project_id: Mapped[int] = mapped_column(
+        BigInteger, ForeignKey("project.project_id"), nullable=False, index=True
+    )
+
+    paper_id: Mapped[int] = mapped_column(
+        BigInteger, ForeignKey("paper.paper_id"), nullable=False, index=True
+    )
+
+    added_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        nullable=False,
+        server_default=func.now(),
+    )
+
+    project: Mapped["Project"] = relationship("Project", back_populates="project_papers")
+    paper: Mapped["Paper"] = relationship("Paper", back_populates="project_links")
+
+
+if TYPE_CHECKING:
+    from .paper import Paper
+    from .project import Project