Merge pull request #23 from ks6088ts-labs/feature/issue-22_blob-storage-service

add blob storage solution

Author: ks6088ts

Makefile

@@ -23,12 +23,12 @@ install-deps: ## install dependencies for production
 
 .PHONY: format-check
 format-check: ## format check
-	poetry run black . --check --verbose
+	poetry run black . --check --extend-exclude client/ --verbose
 
 .PHONY: format
 format: ## format code
 	poetry run isort .
-	poetry run black . --verbose
+	poetry run black . --extend-exclude client/ --verbose
 
 .PHONY: fix
 fix: format ## apply auto-fixes

azure_storage.env.sample

@@ -0,0 +1,3 @@
+AZURE_STORAGE_ACCOUNT_NAME = "<account-name>"
+AZURE_STORAGE_SAS_TOKEN = "<sas-token>"
+AZURE_STORAGE_BLOB_CONTAINER_NAME = "<blob-container-name>"

backend/fastapi.py

@@ -2,6 +2,7 @@
 from fastapi.openapi.utils import get_openapi
 
 from backend.routers import azure_openai as azure_openai_router
+from backend.routers import azure_storage as azure_storage_router
 from backend.routers import document_intelligence as document_intelligence_router
 
 app = FastAPI(
@@ -10,6 +11,7 @@
 
 app.include_router(azure_openai_router.router)
 app.include_router(document_intelligence_router.router)
+app.include_router(azure_storage_router.router)
 
 
 def custom_openapi():

backend/internals/azure_storage.py

@@ -0,0 +1,64 @@
+from logging import getLogger
+
+from azure.storage.blob import BlobServiceClient
+
+from backend.settings import azure_storage as azure_storage_settings
+
+logger = getLogger(__name__)
+
+
+class BlobStorageClient:
+    def __init__(self, settings: azure_storage_settings.Settings):
+        self.settings = settings
+
+    def get_blob_service_client(self) -> BlobServiceClient:
+        return BlobServiceClient(
+            account_url=f"https://{self.settings.azure_storage_account_name}.blob.core.windows.net",
+            credential=self.settings.azure_storage_sas_token,
+        )
+
+    def upload_blob_stream(
+        self,
+        blob_name: str,
+        stream: bytes,
+    ):
+        blob_service_client = self.get_blob_service_client()
+        blob_client = blob_service_client.get_blob_client(
+            container=self.settings.azure_storage_blob_container_name,
+            blob=blob_name,
+        )
+        blob_client.upload_blob(stream, overwrite=True)
+        logger.info(f"Uploaded blob {blob_name} to container {self.settings.azure_storage_blob_container_name}")
+
+    def download_blob_stream(
+        self,
+        blob_name: str,
+    ) -> bytes:
+        blob_service_client = self.get_blob_service_client()
+        blob_client = blob_service_client.get_blob_client(
+            container=self.settings.azure_storage_blob_container_name,
+            blob=blob_name,
+        )
+        stream = blob_client.download_blob().readall()
+        logger.info(f"Downloaded blob {blob_name} from container {self.settings.azure_storage_blob_container_name}")
+        return stream
+
+    def delete_blob(
+        self,
+        blob_name: str,
+    ):
+        blob_service_client = self.get_blob_service_client()
+        blob_client = blob_service_client.get_blob_client(
+            container=self.settings.azure_storage_blob_container_name,
+            blob=blob_name,
+        )
+        blob_client.delete_blob()
+        logger.info(f"Deleted blob {blob_name} from container {self.settings.azure_storage_blob_container_name}")
+
+    def list_blobs(
+        self,
+    ) -> list:
+        blob_service_client = self.get_blob_service_client()
+        container_client = blob_service_client.get_container_client(self.settings.azure_storage_blob_container_name)
+        logger.info(f"Listed blobs in container {self.settings.azure_storage_blob_container_name}")
+        return [blob.name for blob in container_client.list_blobs()]

backend/routers/azure_storage.py

@@ -0,0 +1,78 @@
+from logging import getLogger
+
+from fastapi import APIRouter, UploadFile, status
+from fastapi.responses import JSONResponse
+
+from backend.internals import azure_storage
+from backend.schemas import azure_storage as azure_storage_schemas
+from backend.settings.azure_storage import Settings as AzureStorageSettings
+
+logger = getLogger(__name__)
+blob_storage_client = azure_storage.BlobStorageClient(
+    settings=AzureStorageSettings(),
+)
+
+router = APIRouter(
+    prefix="/azure_storage",
+    tags=["azure_storage"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+@router.post(
+    "/blobs/upload/",
+    response_model=azure_storage_schemas.BlobUploadResponse,
+    status_code=200,
+)
+async def upload_blob(
+    file: UploadFile,
+    blob_name: str,
+):
+    try:
+        content = await file.read()
+        blob_storage_client.upload_blob_stream(
+            blob_name=blob_name,
+            stream=content,
+        )
+    except Exception as e:
+        logger.error(f"Failed to upload blob: {e}")
+        raise
+    return azure_storage_schemas.BlobUploadResponse(
+        blob_name=blob_name,
+    )
+
+
+@router.delete(
+    "/blobs/delete/",
+    status_code=200,
+)
+async def delete_blob(
+    blob_name: str,
+):
+    try:
+        blob_storage_client.delete_blob(
+            blob_name=blob_name,
+        )
+    except Exception as e:
+        logger.error(f"Failed to delete blob: {e}")
+        raise
+    return JSONResponse(
+        status_code=status.HTTP_200_OK,
+        content={"blob_name": blob_name},
+    )
+
+
+@router.get(
+    "/blobs/",
+    status_code=200,
+)
+async def list_blobs():
+    try:
+        blobs = blob_storage_client.list_blobs()
+    except Exception as e:
+        logger.error(f"Failed to upload blob: {e}")
+        raise
+    return JSONResponse(
+        status_code=status.HTTP_200_OK,
+        content={"blobs": blobs},
+    )

backend/schemas/azure_storage.py

@@ -0,0 +1,9 @@
+from logging import getLogger
+
+from pydantic import BaseModel
+
+logger = getLogger(__name__)
+
+
+class BlobUploadResponse(BaseModel):
+    blob_name: str

backend/settings/azure_storage.py

@@ -0,0 +1,12 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    azure_storage_account_name: str = "<account-name>"
+    azure_storage_sas_token: str = "<sas-token>"
+    azure_storage_blob_container_name: str = "<blob-container-name>"
+
+    model_config = SettingsConfigDict(
+        env_file="azure_storage.env",
+        env_file_encoding="utf-8",
+    )

client/api_client.py

@@ -15,6 +15,7 @@
 
 if TYPE_CHECKING:
     from .azure_openai.azure_openai_request_builder import Azure_openaiRequestBuilder
+    from .azure_storage.azure_storage_request_builder import Azure_storageRequestBuilder
     from .document_intelligence.document_intelligence_request_builder import Document_intelligenceRequestBuilder
 
 class ApiClient(BaseRequestBuilder):
@@ -50,6 +51,15 @@ def azure_openai(self) -> Azure_openaiRequestBuilder:
 
         return Azure_openaiRequestBuilder(self.request_adapter, self.path_parameters)
 
+    @property
+    def azure_storage(self) -> Azure_storageRequestBuilder:
+        """
+        The azure_storage property
+        """
+        from .azure_storage.azure_storage_request_builder import Azure_storageRequestBuilder
+
+        return Azure_storageRequestBuilder(self.request_adapter, self.path_parameters)
+    
     @property
     def document_intelligence(self) -> Document_intelligenceRequestBuilder:
         """

client/azure_storage/azure_storage_request_builder.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+from kiota_abstractions.base_request_builder import BaseRequestBuilder
+from kiota_abstractions.get_path_parameters import get_path_parameters
+from kiota_abstractions.request_adapter import RequestAdapter
+from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .blobs.blobs_request_builder import BlobsRequestBuilder
+
+class Azure_storageRequestBuilder(BaseRequestBuilder):
+    """
+    Builds and executes requests for operations under /azure_storage
+    """
+    def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None:
+        """
+        Instantiates a new Azure_storageRequestBuilder and sets the default values.
+        param path_parameters: The raw url or the url-template parameters for the request.
+        param request_adapter: The request adapter to use to execute the requests.
+        Returns: None
+        """
+        super().__init__(request_adapter, "{+baseurl}/azure_storage", path_parameters)
+    
+    @property
+    def blobs(self) -> BlobsRequestBuilder:
+        """
+        The blobs property
+        """
+        from .blobs.blobs_request_builder import BlobsRequestBuilder
+
+        return BlobsRequestBuilder(self.request_adapter, self.path_parameters)
+    
+

client/azure_storage/blobs/blobs_request_builder.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+from kiota_abstractions.base_request_builder import BaseRequestBuilder
+from kiota_abstractions.base_request_configuration import RequestConfiguration
+from kiota_abstractions.get_path_parameters import get_path_parameters
+from kiota_abstractions.method import Method
+from kiota_abstractions.request_adapter import RequestAdapter
+from kiota_abstractions.request_information import RequestInformation
+from kiota_abstractions.request_option import RequestOption
+from kiota_abstractions.serialization import Parsable, ParsableFactory
+from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .delete.delete_request_builder import DeleteRequestBuilder
+    from .upload.upload_request_builder import UploadRequestBuilder
+
+class BlobsRequestBuilder(BaseRequestBuilder):
+    """
+    Builds and executes requests for operations under /azure_storage/blobs
+    """
+    def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None:
+        """
+        Instantiates a new BlobsRequestBuilder and sets the default values.
+        param path_parameters: The raw url or the url-template parameters for the request.
+        param request_adapter: The request adapter to use to execute the requests.
+        Returns: None
+        """
+        super().__init__(request_adapter, "{+baseurl}/azure_storage/blobs", path_parameters)
+    
+    async def get(self,request_configuration: Optional[RequestConfiguration] = None) -> Optional[UntypedNode]:
+        """
+        List Blobs
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: Optional[UntypedNode]
+        """
+        request_info = self.to_get_request_information(
+            request_configuration
+        )
+        if not self.request_adapter:
+            raise Exception("Http core is null") 
+        return await self.request_adapter.send_async(request_info, UntypedNode, None)
+    
+    def to_get_request_information(self,request_configuration: Optional[RequestConfiguration] = None) -> RequestInformation:
+        """
+        List Blobs
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: RequestInformation
+        """
+        request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters)
+        request_info.configure(request_configuration)
+        request_info.headers.try_add("Accept", "application/json")
+        return request_info
+    
+    def with_url(self,raw_url: Optional[str] = None) -> BlobsRequestBuilder:
+        """
+        Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        param raw_url: The raw URL to use for the request builder.
+        Returns: BlobsRequestBuilder
+        """
+        if not raw_url:
+            raise TypeError("raw_url cannot be null.")
+        return BlobsRequestBuilder(self.request_adapter, raw_url)
+    
+    @property
+    def delete_path(self) -> DeleteRequestBuilder:
+        """
+        The deletePath property
+        """
+        from .delete.delete_request_builder import DeleteRequestBuilder
+
+        return DeleteRequestBuilder(self.request_adapter, self.path_parameters)
+    
+    @property
+    def upload(self) -> UploadRequestBuilder:
+        """
+        The upload property
+        """
+        from .upload.upload_request_builder import UploadRequestBuilder
+
+        return UploadRequestBuilder(self.request_adapter, self.path_parameters)
+    
+