saviialib 0.8.0__tar.gz → 0.9.1__tar.gz

{saviialib-0.8.0 → saviialib-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: saviialib
-Version: 0.8.0
+Version: 0.9.1
 Summary: A client library for IoT projects in the RCER initiative
 License: MIT
 Author: pedropablozavalat

{saviialib-0.8.0 → saviialib-0.9.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "saviialib"
-version = "0.8.0"
+version = "0.9.1"
 description = "A client library for IoT projects in the RCER initiative"
 authors = ["pedropablozavalat"]
 license = "MIT"

{saviialib-0.8.0 → saviialib-0.9.1}/src/saviialib/general_types/api/epii_api_types.py

@@ -79,3 +79,4 @@ class EpiiSharepointBackupConfig:
     sharepoint_tenant_name: str
     sharepoint_site_name: str
     local_backup_source_path: str
+    destination_folders: str

{saviialib-0.8.0 → saviialib-0.9.1}/src/saviialib/services/epii/api.py

@@ -53,7 +53,7 @@ class EpiiAPI:
         return response.__dict__
 
     async def upload_backup_to_sharepoint(
-        self, local_backup_source_path: str
+        self, local_backup_source_path: str, destination_folders: dict[str, str]
     ) -> Dict[str, Any]:
         """Migrate a backup folder from Home assistant to Sharepoint directory.
         Args:
@@ -70,6 +70,7 @@ class EpiiAPI:
             sharepoint_tenant_id=self.sharepoint_tenant_id,
             sharepoint_tenant_name=self.sharepoint_tenant_name,
             local_backup_source_path=local_backup_source_path,
+            destination_folders=destination_folders
         )
 
         controller = UploadBackupToSharepointController(

{saviialib-0.8.0 → saviialib-0.9.1}/src/saviialib/services/epii/controllers/upload_backup_to_sharepoint.py

@@ -34,6 +34,7 @@ class UploadBackupToSharepointController:
                     sharepoint_tenant_id=input.config.sharepoint_tenant_id,
                 ),
                 local_backup_source_path=input.config.local_backup_source_path,
+                destination_folders=input.config.destination_folders
             )
         )
 

{saviialib-0.8.0 → saviialib-0.9.1}/src/saviialib/services/epii/use_cases/constants/upload_backup_to_sharepoint_constants.py

@@ -1,5 +1,5 @@
+import logging
+
 SHAREPOINT_BASE_URL = "/sites/uc365_CentrosyEstacionesRegionalesUC/Shared%20Documents/General/Test_Raspberry"
-DESTINATION_FOLDERS = {
-    "CAM1": "Camaras_Trampa",
-    "RECORDS1": "Grabaciones",
-}
+
+LOGGER = logging.getLogger(__package__)

{saviialib-0.8.0 → saviialib-0.9.1}/src/saviialib/services/epii/use_cases/types/upload_backup_to_sharepoint_types.py

@@ -6,3 +6,4 @@ from saviialib.general_types.api.epii_api_types import SharepointConfig
 class UploadBackupToSharepointUseCaseInput:
     sharepoint_config: SharepointConfig
     local_backup_source_path: str
+    destination_folders: dict

{saviialib-0.8.0 → saviialib-0.9.1}/src/saviialib/services/epii/use_cases/upload_backup_to_sharepoint.py

@@ -28,34 +28,40 @@ from saviialib.services.epii.utils.upload_backup_to_sharepoint_utils import (
 from .types.upload_backup_to_sharepoint_types import (
     UploadBackupToSharepointUseCaseInput,
 )
+from .constants.upload_backup_to_sharepoint_constants import LOGGER
 
 
 class UploadBackupToSharepointUsecase:
     def __init__(self, input: UploadBackupToSharepointUseCaseInput):
         self.sharepoint_config = input.sharepoint_config
         self.local_backup_source_path = input.local_backup_source_path
-        self.grouped_files_by_folder = self._extract_filesnames_by_folder()
+        self.destination_folders = input.destination_folders
         self.files_client = self._initialize_files_client()
-        self.total_files = sum(
-            len(files) for files in self.grouped_files_by_folder.values()
-        )
         self.log_history = []
+        self.grouped_files_by_folder = None
+        self.total_files = None
 
     def _initialize_files_client(self):
         return FilesClient(FilesClientInitArgs(client_name="aiofiles_client"))
 
-    def _extract_filesnames_by_folder(self) -> dict[str, list[str]]:
+    async def _extract_filesnames_by_folder(self) -> dict[str, list[str]]:
         """Groups files by their parent folder."""
-        if not os.path.exists(self.local_backup_source_path):
+        backup_folder_exists = await asyncio.to_thread(
+            os.path.exists, self.local_backup_source_path
+        )
+        if not backup_folder_exists:
             return {}
+        folder_names = await asyncio.to_thread(
+            os.listdir, self.local_backup_source_path
+        )
         return {
             folder_name: [
                 file_name
-                for file_name in os.listdir(
-                    os.path.join(self.local_backup_source_path, folder_name)
+                for file_name in await asyncio.to_thread(
+                    os.listdir, os.path.join(self.local_backup_source_path, folder_name)
                 )
             ]
-            for folder_name in os.listdir(self.local_backup_source_path)
+            for folder_name in folder_names
         }
 
     def _save_log_history(self) -> None:
@@ -82,7 +88,9 @@ class UploadBackupToSharepointUsecase:
 
         async with sharepoint_client:
             try:
-                destination_folder = c.DESTINATION_FOLDERS.get(folder_name, folder_name)
+                destination_folder = self.destination_folders.get(
+                    folder_name, folder_name
+                )
                 folder_url = f"{c.SHAREPOINT_BASE_URL}/{destination_folder}"
                 args = SpUploadFileArgs(
                     folder_relative_url=folder_url,
@@ -103,14 +111,14 @@ class UploadBackupToSharepointUsecase:
             f"[BACKUP] Uploading file '{file_name}' from '{folder_name}' "
         )
         self.log_history.append(uploading_message)
-        print(uploading_message)
+        LOGGER.debug(uploading_message)
         file_path = os.path.join(self.local_backup_source_path, folder_name, file_name)
         file_content = await self.files_client.read(ReadArgs(file_path, mode="rb"))
         uploaded, error_message = await self.export_file_to_sharepoint(
             folder_name, file_name, file_content
         )
         result_message = show_upload_result(uploaded, file_name)
-        print(result_message)
+        LOGGER.debug(result_message)
         self.log_history.append(result_message)
         return {
             "parent_folder": folder_name,
@@ -126,7 +134,7 @@ class UploadBackupToSharepointUsecase:
             f"[BACKUP] Retrying upload for {len(failed_files)} failed files... 🚨"
         )
         self.log_history.append(retry_message)
-        print(retry_message)
+        LOGGER.debug(retry_message)
         for file in failed_files:
             tasks.append(
                 self.upload_and_log_progress_task(
@@ -142,40 +150,72 @@ class UploadBackupToSharepointUsecase:
                 "[BACKUP] All files uploaded successfully after retry."
             )
             self.log_history.append(successful_upload_retry)
-            print(successful_upload_retry)
+            LOGGER.debug(successful_upload_retry)
             self._save_log_history()
             return parse_execute_response(results)
 
     async def execute(self):
         """Exports all files from the local backup folder to SharePoint cloud."""
+        self.grouped_files_by_folder = await self._extract_filesnames_by_folder()
+        self.total_files = sum(
+            len(files) for files in self.grouped_files_by_folder.values()
+        )
         tasks = []
         start_time = time()
-        if not directory_exists(self.local_backup_source_path):
+
+        # Check if the local path exists in the main directory
+        if not await directory_exists(self.local_backup_source_path):
             raise BackupSourcePathError(
                 reason=f"'{self.local_backup_source_path}' doesn't exist."
             )
+
+        # Check if the current folder only have files.
+        items = [
+            item
+            for item in await asyncio.to_thread(
+                os.listdir, self.local_backup_source_path
+            )
+        ]
+        for item in items:
+            folder_included = item in self.destination_folders.keys()
+            is_file = not await asyncio.to_thread(
+                os.path.isdir, os.path.join(self.local_backup_source_path, item)
+            )
+
+            if not folder_included and not is_file:
+                raise BackupSourcePathError(
+                    reason=(
+                        f"'{item}' must be included in the destination folders dictionary",
+                    )
+                )
+            elif folder_included and is_file:
+                print(folder_included, is_file)
+                raise BackupSourcePathError(reason=(f"'{item}' must be a directory.",))
+
         if self.total_files == 0:
             no_files_message = (
                 f"[BACKUP] {self.local_backup_source_path} has no files ⚠️"
             )
             self.log_history.append(no_files_message)
-            print(no_files_message)
+            LOGGER.debug(no_files_message)
             raise BackupEmptyError
         # Create task for each file stored in the the local backup folder.
         for folder_name in self.grouped_files_by_folder:
             if (
-                count_files_in_directory(self.local_backup_source_path, folder_name)
+                await count_files_in_directory(
+                    self.local_backup_source_path, folder_name
+                )
                 == 0
             ):
                 empty_folder_message = f"[BACKUP] The folder '{folder_name}' is empty ⚠️"
-                print(empty_folder_message)
+                LOGGER.debug(empty_folder_message)
                 self.log_history.append(empty_folder_message)
                 continue
             extracting_files_message = (
                 "[BACKUP]" + f" Extracting files from '{folder_name} ".center(15, "*")
             )
             self.log_history.append(extracting_files_message)
-            print(extracting_files_message)
+            LOGGER.debug(extracting_files_message)
             for file_name in self.grouped_files_by_folder[folder_name]:
                 tasks.append(self.upload_and_log_progress_task(folder_name, file_name))
 

{saviialib-0.8.0 → saviialib-0.9.1}/src/saviialib/services/epii/utils/upload_backup_to_sharepoint_utils.py

@@ -1,6 +1,13 @@
 import re
 from typing import List, Dict, Optional
+import asyncio
 import os
+from saviialib.general_types.error_types.api.epii_api_error_types import (
+    BackupSourcePathError,
+)
+from saviialib.services.epii.use_cases.constants.upload_backup_to_sharepoint_constants import (
+    LOGGER,
+)
 
 
 def extract_error_information(error: str) -> Optional[Dict[str, str]]:
@@ -24,7 +31,7 @@ def explain_status_code(status_code: int) -> str:
 
 
 def extract_error_message(results: List[Dict], success: float) -> str:
-    print(
+    LOGGER.info(
         "[BACKUP] Not all files uploaded ⚠️\n"
         f"[BACKUP] Files failed to upload: {(1 - success):.2%}"
     )
@@ -52,9 +59,9 @@ def extract_error_message(results: List[Dict], success: float) -> str:
 
     # Summary
     for code, items in grouped_errors.items():
-        print(f"[BACKUP] Status code {code} - {explain_status_code(int(code))}")
+        LOGGER.info(f"[BACKUP] Status code {code} - {explain_status_code(int(code))}")
         for item in items:
-            print(
+            LOGGER.info(
                 f"[BACKUP] File {item['file_name']}, url: {item['url']}, message: {item['message']}"
             )
 
@@ -63,11 +70,14 @@ def extract_error_message(results: List[Dict], success: float) -> str:
 
 
 def parse_execute_response(results: List[Dict]) -> Dict[str, List[str]]:
-    return {
-        "new_files": len(
-            [item["file_name"] for item in results if item.get("uploaded")]
-        ),
-    }
+    try:
+        return {
+            "new_files": len(
+                [item["file_name"] for item in results if item.get("uploaded")]
+            ),
+        }
+    except (IsADirectoryError, AttributeError, ConnectionError) as error:
+        raise BackupSourcePathError(reason=error)
 
 
 def show_upload_result(uploaded: bool, file_name: str) -> str:
@@ -84,9 +94,9 @@ def calculate_percentage_uploaded(results: List[Dict], total_files: int) -> floa
     return (uploaded_count / total_files) * 100 if total_files > 0 else 0
 
 
-def directory_exists(path: str) -> bool:
-    return os.path.exists(path)
+async def directory_exists(path: str) -> bool:
+    return await asyncio.to_thread(os.path.exists, path)
 
 
-def count_files_in_directory(path: str, folder_name: str) -> int:
-    return len(os.listdir(os.path.join(path, folder_name)))
+async def count_files_in_directory(path: str, folder_name: str) -> int:
+    return len(await asyncio.to_thread(os.listdir, os.path.join(path, folder_name)))