fast-mu-builder 0.1.0.3__tar.gz

fast_mu_builder-0.1.0.3/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fast_mu_builder-0.1.0.3/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: fast-mu-builder
+Version: 0.1.0.3
+Summary: FastAPI Builder with Tortoise ORM support for MU
+Home-page: https://bitbucket.org/external-dev-mzumbe/fast-mu-builder
+Author: Japhary Juma Hamisi
+Author-email: Japhary Juma Hamisi <japharyjuma@gmail.com>, Shija Ntula <abuukauthar13@gmail.com>, Juma Ludanga <ludangajn@gmail.com>
+License: Other License
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: FastAPI
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi==0.116.1
+Requires-Dist: tortoise-orm[asyncpg]==0.20.1
+Requires-Dist: pydantic==2.11.7
+Requires-Dist: httpx==0.28.1
+Requires-Dist: strawberry-graphql[fastapi]==0.278.1
+Requires-Dist: jinja2==3.1.6
+Requires-Dist: pluralize==20240519.3
+Requires-Dist: PyJWT==2.10.1
+Requires-Dist: redis==5.2.1
+Requires-Dist: minio==7.2.16
+Requires-Dist: aiofiles==24.1.0
+Requires-Dist: bullmq==2.15.0
+Requires-Dist: sentry_sdk==2.34.1
+Requires-Dist: cryptography==45.0.6
+Requires-Dist: python-decouple==3.8
+Requires-Dist: celery[redis]==5.5.3
+Requires-Dist: xlsxwriter==3.2.5
+Requires-Dist: fpdf2==2.8.3
+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_mu_builder-0.1.0.3/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_mu_builder-0.1.0.3/fast_mu_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_mu_builder.common.response.codes import ResponseCode
+# from fast_mu_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_mu_builder-0.1.0.3/fast_mu_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_mu_builder.attach.request import AttachmentUpload
+from fast_mu_builder.attach.service import MinioService
+from fast_mu_builder.models.attachment import Attachment
+from fast_mu_builder.utils.error_logging import log_exception
+from minio import Minio
+from minio.error import S3Error
+
+from fast_mu_builder.common.response.codes import ResponseCode
+from fast_mu_builder.common.response.schemas import ApiResponse, PaginatedResponse
+from fast_mu_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_mu_builder-0.1.0.3/fast_mu_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_mu_builder-0.1.0.3/fast_mu_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[str] = 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[str] = None