fast-backend-builder 0.1.0__tar.gz

fast_backend_builder-0.1.0/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) 2025 Japhary Juma, Shija Ntula and Juma Nassoro Ludanga
+
+All rights reserved.
+
+This software and associated documentation files (the "Software") are
+provided for use only by licensed users. You may not copy, modify,
+merge, publish, distribute, sublicense, or sell copies of the Software
+without express written permission from the author.

fast_backend_builder-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: fast-backend-builder
+Version: 0.1.0
+Summary: A FastAPI helper/builder package
+Home-page: https://github.com/jay-ludanga/fast-api-builder
+Author: Japhary Juma Hamisi
+Author-email: Japhary Juma <japharyjuma@gmail.com>, Shija Ntula <abuukauthar13@gmail.com>, Juma Ludanga <ludangajn@gmail.com>
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.100
+Requires-Dist: uvicorn>=0.23
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+Building The package:
+
+python setup.py sdist bdist_wheel
+
+install the package to your app:
+
+pip install path/to/wheel file
+
+generating Graphql schemas
+
+graphql gen:crud-api <module-name> --model Model1,Model2,Model3
+
+generating graphql schemas with attachments
+
+graphql gen:crud-api <module-name> --model ModelName --with-attachment
+
+for attachments you must have minio server and these .env configs:
+
+MINIO_SERVER=ip_address:api_port
+MINIO_BUCKET=backet-name
+MINIO_ACCESS_KEY=minio-username
+MINIO_SECRETE_KEY=minio-password
+MINIO_SECURE=False
+
+You must initialize the MinioService before using it by:
+
+@app.on_event("startup")
+async def startup_event():
+    # Run the init_minio_service in the background without blocking the app startup
+    asyncio.create_task(init_minio_service())
+
+async def init_minio_service():
+    minio_service = MinioService()
+    try:
+        await minio_service.init(
+            server=config('MINIO_SERVER'),
+            access_key=config('MINIO_ACCESS_KEY'),
+            secret_key=config('MINIO_SECRETE_KEY'),
+            bucket_name=config('MINIO_BUCKET'),
+            secure=config('MINIO_SECURE', cast=bool)
+        )
+    except Exception as e:
+        print(f"Error initializing MinIO service: {e}")
+
+Making it async will easy your app booting process.
+
+If you need to use the service out of generated crud apis yo do:
+
+For uploading:
+
+file_location, upload_error = await MinioService.get_instance().upload_file(
+    file_name=f"path/to/file.extension",
+    file_data=base64_decoded_file,
+    content_type=attachment.file.content_type
+)
+
+For downloading:
+
+base64_content = await MinioService.get_instance().download_file("path/to/file.extension")
+
+For deleting:
+
+result = MinioService.get_instance().delete_file("path/to/file.extension")
+

fast_backend_builder-0.1.0/README.md

@@ -0,0 +1,64 @@
+Building The package:
+
+python setup.py sdist bdist_wheel
+
+install the package to your app:
+
+pip install path/to/wheel file
+
+generating Graphql schemas
+
+graphql gen:crud-api <module-name> --model Model1,Model2,Model3
+
+generating graphql schemas with attachments
+
+graphql gen:crud-api <module-name> --model ModelName --with-attachment
+
+for attachments you must have minio server and these .env configs:
+
+MINIO_SERVER=ip_address:api_port
+MINIO_BUCKET=backet-name
+MINIO_ACCESS_KEY=minio-username
+MINIO_SECRETE_KEY=minio-password
+MINIO_SECURE=False
+
+You must initialize the MinioService before using it by:
+
+@app.on_event("startup")
+async def startup_event():
+    # Run the init_minio_service in the background without blocking the app startup
+    asyncio.create_task(init_minio_service())
+
+async def init_minio_service():
+    minio_service = MinioService()
+    try:
+        await minio_service.init(
+            server=config('MINIO_SERVER'),
+            access_key=config('MINIO_ACCESS_KEY'),
+            secret_key=config('MINIO_SECRETE_KEY'),
+            bucket_name=config('MINIO_BUCKET'),
+            secure=config('MINIO_SECURE', cast=bool)
+        )
+    except Exception as e:
+        print(f"Error initializing MinIO service: {e}")
+
+Making it async will easy your app booting process.
+
+If you need to use the service out of generated crud apis yo do:
+
+For uploading:
+
+file_location, upload_error = await MinioService.get_instance().upload_file(
+    file_name=f"path/to/file.extension",
+    file_data=base64_decoded_file,
+    content_type=attachment.file.content_type
+)
+
+For downloading:
+
+base64_content = await MinioService.get_instance().download_file("path/to/file.extension")
+
+For deleting:
+
+result = MinioService.get_instance().delete_file("path/to/file.extension")
+

fast_backend_builder-0.1.0/fast_backend_builder/attach/api.py

@@ -0,0 +1,72 @@
+# from typing import List, Optional
+# from fastapi import APIRouter, File, Form, UploadFile, Depends
+# from fastapi.params import Query
+
+# from fast_backend_builder.common.response.codes import ResponseCode
+# from fast_backend_builder.common.response.schemas import ApiResponse
+# from src.modules.auth.permission_middleware import get_current_user, authorize
+# from src.modules.cash.schema import AttachmentCreate
+
+
+# def build_attach_endpoints(router: APIRouter, path: str, controller, parent_id_name: str,
+#                                model_verbose: Optional[str] = None,
+#                                security_dependency=Depends(get_current_user)):
+#     @router.post(f"{path}/attachments/single/upload")
+#     @authorize([f"src.add_{model_verbose}"])
+#     def upload_single_attachment(parent_id: int, file: UploadFile = File(...), title: str = Form(...),
+#                            current_user: dict = security_dependency):
+#         try:
+#             attachments: List[AttachmentCreate] = [
+#                 AttachmentCreate(
+#                     parent_id=parent_id,
+#                     title=title,
+#                     content=file
+#                 )
+#             ]
+            
+#             return controller.upload_attachments(attachments, parent_id_name)
+#         except Exception as e:
+#             return ApiResponse(
+#                 status=False,
+#                 code=ResponseCode.FAILURE,
+#                 message=f"An error occured while uploading attachment. Retry",
+#             )
+            
+#     @router.post(f"{path}/attachments/upload")
+#     @authorize([f"src.add_{model_verbose}"])
+#     def upload_attachments(parent_id: int, files: List[UploadFile] = File(...), titles: List[str] = Form(...),
+#                            current_user: dict = security_dependency):
+#         try:
+#             attachments: List[AttachmentCreate] = []
+#             for index, file in enumerate(files):
+#                 attachments.append(
+#                     AttachmentCreate(
+#                         parent_id=parent_id,
+#                         title=titles[index],
+#                         content=file
+#                     )
+#                 )
+#             return controller.upload_attachments(attachments, parent_id_name)
+#         except IndexError as e:
+#             return ApiResponse(
+#                 status=False,
+#                 code=ResponseCode.BAD_REQUEST,
+#                 message=f"Titles and Files do not match {len(files)} - {len(titles)}",
+#             )
+
+#     @router.get(f"{path}/attachments/get")
+#     @authorize([f"src.view_{model_verbose}"])
+#     def get_attachments(parent_id: int, current_user: dict = security_dependency):
+#         return controller.get_attachments(parent_id, parent_id_name)
+
+#     @router.get(f"{path}/attachments/download")
+#     @authorize([f"src.change_{model_verbose}"])
+#     def download_attachment(attachment_id: int, current_user: dict = security_dependency):
+#         return controller.download_attachment(attachment_id)
+
+#     @router.delete(f"{path}/attachments/remove")
+#     @authorize([f"src.delete_{model_verbose}"])
+#     def delete_attachment(attachment_id: int, current_user: dict = security_dependency):
+#         return controller.remove_attachment(attachment_id)
+
+#     return router

fast_backend_builder-0.1.0/fast_backend_builder/attach/gql_controller.py

@@ -0,0 +1,219 @@
+import base64
+from io import BytesIO
+import os
+from typing import Generic, Type
+
+from tortoise.exceptions import DoesNotExist
+from decouple import config
+from fast_backend_builder.attach.request import AttachmentUpload
+from fast_backend_builder.attach.service import MinioService
+from fast_backend_builder.models.attachment import Attachment
+from fast_backend_builder.utils.error_logging import log_exception
+from minio import Minio
+from minio.error import S3Error
+
+from fast_backend_builder.common.response.codes import ResponseCode
+from fast_backend_builder.common.response.schemas import ApiResponse, PaginatedResponse
+from fast_backend_builder.common.schemas import ModelType
+
+
+# MinIO setup
+class AttachmentBaseController(Generic[ModelType]):
+    def __init__(self, model: Type[ModelType]):
+        self.model = model
+
+    async def upload_attachment(self, attachment_type_id, attachment: AttachmentUpload) -> ApiResponse:
+        try:
+            # Check if model exists
+            obj = await self.model.get(id=attachment_type_id)
+            # Decode the base64 string into binary data (bytes)
+            try:
+                decoded_file = base64.b64decode(attachment.file.content)
+            except Exception as decode_error:
+                return ApiResponse(
+                    status=False,
+                    code=ResponseCode.FAILURE,
+                    message=f"Failed to decode base64 file: {decode_error}",
+                    data=None
+                )
+            
+            # Create Minio FIle name
+            file_name = f"{attachment.file.name}_{os.urandom(4).hex()}.{attachment.file.extension}"
+            
+            file_location, upload_error = await MinioService.get_instance().upload_file(
+                file_name=f"{self.model.__name__}/{file_name}",
+                file_data=decoded_file,
+                content_type=attachment.file.content_type
+            )
+            
+            if not file_location:
+                return ApiResponse(
+                    status=False,
+                    code=ResponseCode.FAILURE,
+                    message=f"File upload failed: {upload_error}",
+                    data=None
+                )
+
+            # Only after a successful upload, store the file path in the database
+            try:
+                attachment = await Attachment.create(
+                    title=attachment.title,
+                    description=attachment.description,
+                    file_path=file_name,
+                    mem_type=attachment.file.content_type,
+                    attachment_type=self.model.__name__,
+                    attachment_type_id=attachment_type_id
+                )
+            except Exception as db_error:
+                log_exception(Exception(db_error))
+                return ApiResponse(
+                    status=False,
+                    code=ResponseCode.BAD_REQUEST,
+                    message=f"Database error: {db_error}",
+                    data=None
+                )
+
+            # Return success response after successful upload and database insertion
+            return ApiResponse(
+                status=True,
+                code=ResponseCode.SUCCESS,
+                message="File uploaded and saved successfully!",
+                data=attachment
+            )
+        except DoesNotExist:
+            return ApiResponse(
+                status=False,
+                code=ResponseCode.NO_RECORD_FOUND,
+                message=f"{self.model.Meta.verbose_name} does not exist",
+                data=None
+            )
+        except Exception as e:
+            # Handle general exceptions
+            log_exception(Exception(e))
+            return ApiResponse(
+                status=False,
+                code=ResponseCode.FAILURE,
+                message=f"Unexpected error occurred, try again!",
+                data=None
+            )
+
+    async def delete_attachment(self, attachment_id: str) -> ApiResponse:
+        try:
+            attachment = await Attachment.get(id=attachment_id)
+            # Retrieve the file from MinIO
+            result = MinioService.get_instance().delete_file(f"{self.model.__name__}/{attachment.file_path}")
+
+            await attachment.delete()
+            # Return success response with file content
+            return ApiResponse(
+                status=True,
+                code=ResponseCode.SUCCESS,
+                message="Attachment deleted successfully!",
+                data=result
+            )
+        except DoesNotExist:
+            return ApiResponse(
+                status=False,
+                code=ResponseCode.NO_RECORD_FOUND,
+                message=f"Attachment does not exist",
+                data=None
+            )
+        except Exception as e:
+            # Handle errors in file retrieval
+            return ApiResponse(
+                status=False,
+                code=ResponseCode.NO_RECORD_FOUND,
+                message=f"An error occurred while deleting the attachment: {e}",
+                data=None
+            )
+            
+    async def get_attachments(self, model_id: str) -> ApiResponse:
+        try:
+            attachments = await Attachment.filter(attachment_type_id=model_id, attachment_type=self.model.__name__)
+
+            return ApiResponse(
+                status=True,
+                code=ResponseCode.SUCCESS,
+                message=f"{self.model.Meta.verbose_name} attachments fetched successfully",
+                data=PaginatedResponse(
+                    items=attachments,
+                    item_count=len(attachments),
+                )
+            )
+        except Exception as e:
+            log_exception(Exception(e))
+            return ApiResponse(
+                status=False,
+                code=ResponseCode.BAD_REQUEST,
+                message=f"Failed to fetch {self.model.Meta.verbose_name} attachments. Try again",
+                data=None
+            )
+            
+    async def download_attachment(self, file_path: str) -> ApiResponse:
+        try:
+            # Call the async download_file method to get the base64 content
+            base64_content = await MinioService.get_instance().download_file(f"{self.model.__name__}/{file_path}")
+
+            if base64_content is False:
+                return ApiResponse(
+                    status=False,
+                    code=ResponseCode.NO_RECORD_FOUND,
+                    message="File not found or an error occurred while retrieving the file.",
+                    data=None
+                )
+
+            # Return success response with base64 content
+            return ApiResponse(
+                status=True,
+                code=ResponseCode.SUCCESS,
+                message="File retrieved successfully!",
+                data=base64_content.decode('utf-8') # Convert bytes to string
+            )
+
+        except Exception as e:
+            # Handle errors in file retrieval
+            return ApiResponse(
+                status=False,
+                code=ResponseCode.NO_RECORD_FOUND,
+                message=f"An error occurred while retrieving the file: {e}",
+                data=None
+            )
+
+    async def download_attachment_url(self, file_path: str, expiry_seconds: int = 3600) -> ApiResponse:
+        """
+        Generate a signed URL for downloading a file from MinIO.
+
+        :param file_path: Relative path to the file in the bucket.
+        :param expiry_seconds: Time in seconds for which the signed URL will be valid.
+        :return: ApiResponse containing the signed URL or error.
+        """
+        try:
+            full_path = f"{self.model.__name__}/{file_path}" if hasattr(self, 'model') else file_path
+
+            signed_url = await MinioService.get_instance().get_signed_url(full_path, expiry_seconds=expiry_seconds)
+
+            if not signed_url:
+                return ApiResponse(
+                    status=False,
+                    code=ResponseCode.NO_RECORD_FOUND,
+                    message="Failed to generate signed URL or file does not exist.",
+                    data=None
+                )
+
+            return ApiResponse(
+                status=True,
+                code=ResponseCode.SUCCESS,
+                message="Signed URL generated successfully!",
+                data=signed_url
+            )
+
+        except Exception as e:
+            return ApiResponse(
+                status=False,
+                code=ResponseCode.FAILURE,
+                message=f"An error occurred while generating signed URL: {e}",
+                data=None
+            )
+
+
+

fast_backend_builder-0.1.0/fast_backend_builder/attach/request.py

@@ -0,0 +1,17 @@
+import strawberry
+from typing import Optional
+
+@strawberry.input
+class AttachmentFile:
+    content: str
+    content_type: str
+    name: str
+    extension: str
+
+@strawberry.input
+class AttachmentUpload:
+    title: Optional[str] = None
+    description: Optional[str] = None
+    attachment_type_category: Optional[str] = None
+    file: AttachmentFile
+    

fast_backend_builder-0.1.0/fast_backend_builder/attach/response.py

@@ -0,0 +1,16 @@
+from typing import Optional
+import strawberry
+
+from typing import Optional
+import strawberry
+
+@strawberry.type
+class AttachmentResponse:
+    id: Optional[int] = None
+    title: Optional[str] = None
+    description: Optional[str] = None
+    file_path: Optional[str] = None
+    mem_type: Optional[str] = None
+    attachment_type: Optional[str] = None
+    attachment_type_category: Optional[str] = None
+    attachment_type_id: Optional[int] = None

fast_backend_builder-0.1.0/fast_backend_builder/attach/service.py

@@ -0,0 +1,162 @@
+
+import base64
+from minio import Minio
+from minio.error import S3Error
+import asyncio
+import threading
+import aiofiles
+from io import BytesIO
+from datetime import timedelta
+
+from fast_backend_builder.utils.error_logging import log_exception
+
+class MinioService:
+    _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(MinioService, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if not hasattr(self, 'initialized'):
+            self.minio_client = None
+            self.bucket_name = None
+            self.initialized = False
+
+    @classmethod
+    def get_instance(cls):
+        """Get the initialized instance of MinioService."""
+        if cls._instance is None or not cls._instance.initialized:
+            raise Exception("MinIO service is not initialized.")
+        return cls._instance
+
+    async def init(self, server: str, access_key: str, secret_key: str, bucket_name: str, secure: bool = True):
+        """Initialize the MinIO service asynchronously with the given configuration."""
+        try:
+            if not self.initialized:
+                self.minio_client = Minio(
+                    endpoint=server,
+                    access_key=access_key,
+                    secret_key=secret_key,
+                    secure=secure
+                )
+                self.bucket_name = bucket_name
+
+                # Ensure bucket exists or create it
+                if not self.minio_client.bucket_exists(bucket_name):
+                    self.minio_client.make_bucket(bucket_name)
+
+                self.initialized = True
+                print(f"MinIO initialized with bucket '{bucket_name}'")
+            else:
+                print("MinIO service is already initialized.")
+            return True
+        except S3Error as e:
+            log_exception(e)
+            return False
+
+    async def upload_file(self, file_name: str, file_data: bytes, content_type: str):
+        """Save a file to the MinIO bucket asynchronously and return the file path when successful or False when failed."""
+        # Check if MinIO service is initialized
+        if not self.initialized:
+            print("MinIO service not initialized.")
+            return False, 'Files service not initialized'
+
+        try:
+            # Use BytesIO to simulate async operation (Minio SDK is not natively async)
+            data = BytesIO(file_data)
+            await asyncio.to_thread(
+                self.minio_client.put_object, 
+                self.bucket_name, 
+                file_name, 
+                data, 
+                len(file_data), 
+                content_type=content_type
+            )
+            print(f"File '{file_name}' saved successfully.")
+            file_url = f"{self.bucket_name}/{file_name}"
+            return file_url, None  # Return the file path
+        except S3Error as e:
+            log_exception(e)
+            return False, f"Error uploading file '{file_name}'"
+
+    async def delete_file(self, file_name: str):
+        """Delete a file from the MinIO bucket asynchronously."""
+        if not self.initialized:
+            print("MinIO service not initialized.")
+            return False, 'Files service not initialized'
+
+        try:
+            await asyncio.to_thread(self.minio_client.remove_object, self.bucket_name, file_name)
+            print(f"File '{file_name}' deleted successfully.")
+            return True
+        except S3Error as e:
+            log_exception(e)
+            return False  # Return False if failed
+
+    async def download_file(self, file_name: str):
+        """Download a file from the MinIO bucket asynchronously and return it as base64 bytes."""
+        self._ensure_initialized()
+
+        try:
+            data = await asyncio.to_thread(self.minio_client.get_object, self.bucket_name, file_name)
+            file_bytes = await asyncio.to_thread(data.read)  # Read the entire file into memory
+
+            # Encode the bytes to base64
+            base64_bytes = base64.b64encode(file_bytes)
+
+            print(f"File '{file_name}' downloaded successfully as base64.")
+            return base64_bytes  # Return the base64-bytes
+        except S3Error as e:
+            log_exception(e)
+            return False  # Return False if failed
+
+
+    async def download_byte_file(self, file_name: str):
+        """
+        Download a file from the MinIO bucket asynchronously and return raw bytes.
+        """
+        self._ensure_initialized()
+        try:
+            # Fetch file from MinIO
+            data = await asyncio.to_thread(self.minio_client.get_object, self.bucket_name, file_name)
+            # Read raw bytes
+            file_bytes = await asyncio.to_thread(data.read)
+            print(f"File '{file_name}' downloaded successfully")
+            return file_bytes  # Return raw bytes
+        except S3Error as e:
+            print(f"Error downloading file: {e}")
+            log_exception(e)
+            return None
+
+    async def get_signed_url(self, file_name: str, expiry_seconds: int = 3600):
+        """
+        Generate a pre-signed URL for a file stored in MinIO.
+
+        :param file_name: The name of the file in the bucket.
+        :param expiry_seconds: Time in seconds until the URL expires (default is 1 hour).
+        :return: A signed URL string or None if an error occurred.
+        """
+        self._ensure_initialized()
+
+        try:
+            url = await asyncio.to_thread(
+                self.minio_client.presigned_get_object,
+                self.bucket_name,
+                file_name,
+                expires=timedelta(seconds=expiry_seconds)
+            )
+            print(f"Generated signed URL for '{file_name}': {url}")
+            return url
+        except S3Error as e:
+            log_exception(e)
+            return None
+
+    def _ensure_initialized(self):
+        """Check if the MinIO service is initialized, else raise an error."""
+        if not self.initialized:
+            raise Exception("MinIO service is not initialized. Call `init()` first.")

fast_backend_builder-0.1.0/fast_backend_builder/attach/templates/attachment_mutations.py

@@ -0,0 +1,6 @@
+
+def upload_attachment():
+    pass
+
+def delete_attachment():
+    pass

fast_backend_builder-0.1.0/fast_backend_builder/attach/templates/attachment_queries.py

@@ -0,0 +1,7 @@
+@strawberry.field
+async def get_attachments():
+    pass
+
+@strawberry.field
+def download_attachment():
+    pass

fast_backend_builder-0.1.0/fast_backend_builder/attach/templates/gql_input_template.py

@@ -0,0 +1,9 @@
+from typing import Optional
+import strawberry
+
+from fast_backend_builder.attach.request import AttachmentUpload
+
+'''ATTACHMENT_UPLOAD'''
+@strawberry.input
+class _MODEL_Attachment(AttachmentUpload):
+    pass

fast_backend_builder-0.1.0/fast_backend_builder/attach/templates/gql_type_template.py

@@ -0,0 +1,9 @@
+from typing import Optional
+import strawberry
+
+from fast_backend_builder.attach.response import AttachmentResponse
+
+'''ATTACHMENT_RESPONSE'''
+@strawberry.type
+class _MODEL_AttachmentResponse(AttachmentResponse):
+    pass