fastapi-rtk 1.0.8__py3-none-any.whl → 1.0.9__py3-none-any.whl

fastapi_rtk/file_managers/s3_file_manager.py

@@ -1,3 +1,5 @@
+import typing
+
 from ..bases.file_manager import AbstractFileManager
 from ..const import logger
 from ..utils import smart_run
@@ -12,20 +14,58 @@ class S3FileManager(AbstractFileManager):
 
     def __init__(
         self,
-        base_path=None,
-        allowed_extensions=None,
-        namegen=None,
-        permission=None,
-        bucket_name=None,
-        bucket_subfolder=None,
-        access_key=None,
-        secret_key=None,
+        base_path: str | None = None,
+        allowed_extensions: list[str] | None = None,
+        namegen: typing.Callable[[str], str] | None = None,
+        permission: int | None = None,
+        bucket_name: str | None = None,
+        bucket_subfolder: str | None = None,
+        access_key: str | None = None,
+        secret_key: str | None = None,
+        open_params: dict[str, typing.Any] | None = None,
+        boto3_client: typing.Any | None = None,
     ):
+        """
+        Initializes the S3FileManager.
+
+        Args:
+            base_path (str | None, optional): URL path to the S3 bucket. Defaults to None.
+            allowed_extensions (list[str] | None, optional): Allowed file extensions. Defaults to None.
+            namegen (typing.Callable[[str], str] | None, optional): Callable for generating file names. Defaults to None.
+            permission (int | None, optional): File permission settings. Defaults to None.
+            bucket_name (str | None, optional): Name of the S3 bucket. Defaults to None.
+            bucket_subfolder (str | None, optional): Subfolder within the S3 bucket. Defaults to None.
+            access_key (str | None, optional): AWS access key. Needed for default boto3 client in order to delete files. Defaults to None.
+            secret_key (str | None, optional): AWS secret key. Needed for default boto3 client in order to delete files. Defaults to None.
+            open_params (dict[str, typing.Any] | None, optional): Parameters for opening files. Defaults to None.
+            boto3_client (typing.Any | None, optional): Boto3 client instance. If None, a new client will be created. Defaults to None.
+        Raises:
+            ImportError: If required libraries are not installed.
+        """
         super().__init__(base_path, allowed_extensions, namegen, permission)
+
+        try:
+            import boto3
+            import smart_open
+
+            self.smart_open = smart_open
+            self.boto3 = boto3
+        except ImportError:
+            raise ImportError(
+                "smart_open is required for S3FileManager. "
+                "Please install it with 'pip install smart_open[s3]'."
+            )
+
         self.bucket_name = bucket_name
         self.bucket_subfolder = bucket_subfolder
         self.access_key = access_key
         self.secret_key = secret_key
+        self.open_params = open_params or {}
+        self.boto3_client = boto3_client or self.boto3.client(
+            "s3",
+            aws_access_key_id=self.access_key,
+            aws_secret_access_key=self.secret_key,
+        )
 
         if not self.bucket_name:
             logger.warning(
@@ -39,52 +79,41 @@ class S3FileManager(AbstractFileManager):
                 "Files may not be able to be deleted"
             )
 
-        try:
-            import boto3
-            import smart_open
-
-            self.smart_open = smart_open
-            self.boto3 = boto3
-        except ImportError:
-            raise ImportError(
-                "smart_open is required for S3FileManager. "
-                "Please install it with 'pip install smart_open[s3]'."
-            )
-
     def get_path(self, filename):
         return self.base_path + "/" + filename
 
     def get_file(self, filename):
-        with self.smart_open.open(self.get_path(filename), "rb") as f:
+        with self.smart_open.open(
+            self.get_path(filename), "rb", **self.open_params
+        ) as f:
             return f.read()
 
     async def stream_file(self, filename):
-        with self.smart_open.open(self.get_path(filename), "rb") as f:
+        with self.smart_open.open(
+            self.get_path(filename), "rb", **self.open_params
+        ) as f:
             while chunk := await smart_run(f.read, 8192):
                 yield chunk
 
     def save_file(self, file_data, filename):
         path = self.get_path(filename)
-        with self.smart_open.open(path, "wb") as f:
+        with self.smart_open.open(path, "wb", **self.open_params) as f:
             f.write(file_data.file.read())
         return path
 
     def save_content_to_file(self, content, filename):
         path = self.get_path(filename)
-        with self.smart_open.open(path, "wb") as f:
+        with self.smart_open.open(path, "wb", **self.open_params) as f:
             f.write(content)
         return path
 
     def delete_file(self, filename):
         path = self.get_path(filename)
         try:
-            self.smart_open.open(path, "rb").close()  # Check if file exists
-            s3 = self.boto3.client(
-                "s3",
-                aws_access_key_id=self.access_key,
-                aws_secret_access_key=self.secret_key,
-            )
-            s3.delete_object(
+            self.smart_open.open(
+                path, "rb", **self.open_params
+            ).close()  # Check if file exists
+            self.boto3_client.delete_object(
                 Bucket=self.bucket_name,
                 Key=f"{self.bucket_subfolder}/{filename}"
                 if self.bucket_subfolder
@@ -96,7 +125,7 @@ class S3FileManager(AbstractFileManager):
     def file_exists(self, filename):
         path = self.get_path(filename)
         try:
-            with self.smart_open.open(path, "rb"):
+            with self.smart_open.open(path, "rb", **self.open_params):
                 return True
         except FileNotFoundError:
             return False
@@ -110,6 +139,8 @@ class S3FileManager(AbstractFileManager):
             else subfolder,
             access_key=self.access_key,
             secret_key=self.secret_key,
+            open_params=self.open_params,
+            boto3_client=self.boto3_client,
             *args,
             **kwargs,
         )

fastapi_rtk/security/sqla/apis.py

@@ -1,5 +1,6 @@
 from typing import List
 
+import sqlalchemy
 from fastapi import Depends, HTTPException, Request, status
 from pydantic import BaseModel, EmailStr, Field
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -8,7 +9,7 @@ from sqlalchemy.orm import Session
 from ...api import BaseApi, ModelRestApi
 from ...backends.sqla.interface import SQLAInterface
 from ...const import ErrorCode
-from ...db import UserDatabase, get_user_db
+from ...db import UserDatabase, db, get_user_db
 from ...decorators import expose, login_required
 from ...globals import g
 from ...lang import translate
@@ -21,7 +22,7 @@ from ...schemas import (
     generate_user_update_schema,
 )
 from ...setting import Setting
-from ...utils import SelfType, lazy, merge_schema
+from ...utils import SelfType, lazy, merge_schema, smart_run
 from .models import Api, Permission, PermissionApi, Role, User
 
 __all__ = [
@@ -275,12 +276,26 @@ class AuthApi(BaseApi):
             },
         )(self.update_user)
 
-    def get_user(self):
+    async def get_user(self):
         if not g.user:
             raise HTTPException(
                 status.HTTP_401_UNAUTHORIZED,
                 ErrorCode.GET_USER_MISSING_TOKEN_OR_INACTIVE_USER,
             )
+
+        g.user.permissions = []
+        if g.user.roles:
+            # Retrieve list of api names that user has access to
+            query = (
+                sqlalchemy.select(Api.name)
+                .join(PermissionApi)
+                .join(PermissionApi.roles)
+                .where(Role.id.in_([role.id for role in g.user.roles]))
+                .distinct()
+            )
+            result = await smart_run(db.current_session.scalars, query)
+            g.user.permissions = list(result)
+
         return g.user
 
     async def update_user(

fastapi_rtk/security/sqla/models.py

@@ -76,22 +76,15 @@ class PermissionApi(Model):
     api_id: Mapped[int] = mapped_column(
         Integer, ForeignKey(f"{API_TABLE}.id"), name=view_menu_id, nullable=False
     )
-    api: Mapped["Api"] = relationship(
-        "Api", back_populates="permissions", lazy="selectin"
-    )
+    api: Mapped["Api"] = relationship("Api", back_populates="permissions")
 
     permission_id: Mapped[int] = mapped_column(
         Integer, ForeignKey(f"{PERMISSION_TABLE}.id"), nullable=False
     )
-    permission: Mapped["Permission"] = relationship(
-        "Permission", back_populates="apis", lazy="selectin"
-    )
+    permission: Mapped["Permission"] = relationship("Permission", back_populates="apis")
 
     roles: Mapped[list["Role"]] = relationship(
-        "Role",
-        secondary=assoc_permission_api_role,
-        back_populates="permissions",
-        lazy="selectin",
+        "Role", secondary=assoc_permission_api_role, back_populates="permissions"
     )
 
     def __repr__(self) -> str:
@@ -104,10 +97,7 @@ class Api(Model):
     name: Mapped[str] = mapped_column(String, unique=True, nullable=False)
 
     permissions: Mapped[list[PermissionApi]] = relationship(
-        PermissionApi,
-        back_populates="api",
-        lazy="selectin",
-        cascade="all, delete-orphan",
+        PermissionApi, back_populates="api", cascade="all, delete-orphan"
     )
 
     def __eq__(self, other):
@@ -128,10 +118,7 @@ class Permission(Model):
     name: Mapped[str] = mapped_column(String, unique=True, nullable=False)
 
     apis: Mapped[list[PermissionApi]] = relationship(
-        PermissionApi,
-        back_populates="permission",
-        lazy="selectin",
-        cascade="all, delete-orphan",
+        PermissionApi, back_populates="permission", cascade="all, delete-orphan"
     )
 
     def __repr__(self) -> str:
@@ -144,14 +131,11 @@ class Role(Model):
     name: Mapped[str] = mapped_column(String, unique=True, nullable=False)
 
     users: Mapped[list["User"]] = relationship(
-        "User", secondary=assoc_user_role, back_populates="roles", lazy="selectin"
+        "User", secondary=assoc_user_role, back_populates="roles"
     )
 
     permissions: Mapped[list[PermissionApi]] = relationship(
-        PermissionApi,
-        secondary=assoc_permission_api_role,
-        back_populates="roles",
-        lazy="selectin",
+        PermissionApi, secondary=assoc_permission_api_role, back_populates="roles"
     )
 
     def __repr__(self) -> str:
@@ -203,10 +187,7 @@ class User(Model):
         return Column(Integer, ForeignKey("ab_user.id"), default=self.get_user_id)
 
     oauth_accounts: Mapped[list[OAuthAccount]] = relationship(
-        "OAuthAccount",
-        back_populates="user",
-        lazy="selectin",
-        cascade="all, delete-orphan",
+        "OAuthAccount", back_populates="user", cascade="all, delete-orphan"
     )
 
     roles: Mapped[list[Role]] = relationship(