saviialib 0.10.2__tar.gz → 0.11.0__tar.gz

{saviialib-0.10.2 → saviialib-0.11.0}/PKG-INFO

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

{saviialib-0.10.2 → saviialib-0.11.0}/pyproject.toml

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

{saviialib-0.10.2 → saviialib-0.11.0}/src/saviialib/general_types/api/epii_api_types.py

@@ -80,6 +80,4 @@ class EpiiSharepointBackupConfig:
     sharepoint_tenant_id: str
     sharepoint_tenant_name: str
     sharepoint_site_name: str
-    local_backup_source_path: str
-    destination_folders: str
     logger: Logger

{saviialib-0.10.2 → saviialib-0.11.0}/src/saviialib/general_types/error_types/api/epii_api_error_types.py

@@ -43,6 +43,18 @@ class SharePointFetchingError(Exception):
             return self.reason.__str__()
 
 
+class SharePointDirectoryError(Exception):
+    def __init__(self, *args, reason):
+        super().__init__(*args, reason)
+        self.reason = reason
+
+    def __str__(self):
+        return (
+            "An error occurred while fetching the folders from Microsoft SharePoint. "
+            + self.reason.__str__()
+        )
+
+
 class SharePointUploadError(Exception):
     """Raised when there is an error uploading files to the Microsoft SharePoint folder."""
 

{saviialib-0.10.2 → saviialib-0.11.0}/src/saviialib/libs/ftp_client/clients/aioftp_client.py

@@ -34,12 +34,16 @@ class AioFTPClient(FTPClientContract):
             )
 
     async def list_files(self, args: FtpListFilesArgs) -> list[str]:
-        await self._async_start()
-        return [
-            path.name async for path, _ in self.client.list(args.path, recursive=False)
-        ]
+        try:
+            await self._async_start()
+            return [
+                path.name
+                async for path, _ in self.client.list(args.path, recursive=False)  # type: ignore
+            ]
+        except StatusCodeError as error:
+            raise ConnectionAbortedError(error)
 
     async def read_file(self, args: FtpReadFileArgs) -> bytes:
         await self._async_start()
-        async with self.client.download_stream(args.file_path) as stream:
+        async with self.client.download_stream(args.file_path) as stream:  # type: ignore
             return await stream.read()

{saviialib-0.10.2 → saviialib-0.11.0}/src/saviialib/libs/ftp_client/ftp_client.py

@@ -15,8 +15,8 @@ class FTPClient(FTPClientContract):
             self.client_obj = AioFTPClient(args)
         self.client_name = args.client_name
 
-    def list_files(self, args: FtpListFilesArgs) -> list[str]:
-        return self.client_obj.list_files(args)
+    async def list_files(self, args: FtpListFilesArgs) -> list[str]:
+        return await self.client_obj.list_files(args)
 
-    def read_file(self, args: FtpReadFileArgs) -> bytes:
-        return self.client_obj.read_file(args)
+    async def read_file(self, args: FtpReadFileArgs) -> bytes:
+        return await self.client_obj.read_file(args)

{saviialib-0.10.2 → saviialib-0.11.0}/src/saviialib/libs/ftp_client/ftp_client_contract.py

@@ -5,9 +5,9 @@ from .types.ftp_client_types import FtpListFilesArgs, FtpReadFileArgs
 
 class FTPClientContract(ABC):
     @abstractmethod
-    def list_files(self, args: FtpListFilesArgs) -> list[str]:
+    async def list_files(self, args: FtpListFilesArgs) -> list[str]:
         pass
 
     @abstractmethod
-    def read_file(self, args: FtpReadFileArgs) -> bytes:
+    async def read_file(self, args: FtpReadFileArgs) -> bytes:
         pass

{saviialib-0.10.2 → saviialib-0.11.0}/src/saviialib/libs/sharepoint_client/clients/sharepoint_rest_api.py

@@ -104,10 +104,11 @@ class SharepointRestAPI(SharepointClientContract):
             folder_relative_url = (
                 f"GetFolderByServerRelativeUrl('{args.folder_relative_url}')"
             )
-            endpoint = f"web/{folder_relative_url}/Folder"
+            endpoint = f"web/{folder_relative_url}/Folders"
             response = await self.session.get(endpoint.lstrip("/"))
             response.raise_for_status()
-            return await response.json()
+            response_json = await response.json()
+            return response_json
         except ClientError as error:
             raise ConnectionError(error) from error
 

{saviialib-0.10.2 → saviialib-0.11.0}/src/saviialib/libs/sharepoint_client/sharepoint_client.py

@@ -18,6 +18,26 @@ class SharepointClient(SharepointClientContract):
         elif args.client_name == "sharepoint_rest_api":
             self.client_obj = SharepointRestAPI(args)
 
+    @property
+    def tenant_id(self):
+        return self.client_obj.tenant_id
+
+    @property
+    def tenant_name(self):
+        return self.client_obj.tenant_name
+
+    @property
+    def site_name(self):
+        return self.client_obj.site_name
+
+    @property
+    def client_id(self):
+        return self.client_obj.client_id
+
+    @property
+    def client_secret(self):
+        return self.client_obj.client_secret
+
     async def __aenter__(self):
         return await self.client_obj.__aenter__()
 
@@ -28,7 +48,7 @@ class SharepointClient(SharepointClientContract):
         return await self.client_obj.list_files(args)
 
     async def list_folders(self, args: SpListFoldersArgs) -> list:
-        return await self.client_obj.list_files(args)
+        return await self.client_obj.list_folders(args)
 
     async def upload_file(self, args: SpUploadFileArgs) -> dict:
         return await self.client_obj.upload_file(args)

{saviialib-0.10.2 → saviialib-0.11.0}/src/saviialib/services/epii/api.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Any, Dict, List
 
 from .controllers.types.update_thies_data_types import UpdateThiesDataControllerInput
 from .controllers.types.upload_backup_to_sharepoint_types import (
@@ -28,15 +28,21 @@ class EpiiAPI:
         self.sharepoint_tenant_id = config.sharepoint_tenant_id
         self.sharepoint_tenant_name = config.sharepoint_tenant_name
         self.sharepoint_site_name = config.sharepoint_site_name
+
         self.logger = config.logger
 
-    async def update_thies_data(self) -> Dict[str, Any]:
-        """
-        This method establishes a connection to an FTP server using the provided
-        credentials and updates data related to THIES Data Logger.
+    async def update_thies_data(
+        self, sharepoint_folders_path: List[str], ftp_server_folders_path: List[str]
+    ) -> Dict[str, Any]:
+        """Updates data from a THIES Data Logger by connecting to an FTP server
+        and transferring data to specified Sharepoint folders.
+
+        Args:
+            sharepoint_folders_path (list): List of Sharepoint folder paths for AVG and EXT data.
+            ftp_server_folders_path (list): List of FTP server folder paths for AVG and EXT data.
 
         Returns:
-            response (dict): A dictionary representation of the API response.
+            dict: A dictionary representation of the API response.
         """
         config = EpiiUpdateThiesConfig(
             ftp_port=self.ftp_port,
@@ -49,12 +55,16 @@ class EpiiAPI:
             sharepoint_tenant_id=self.sharepoint_tenant_id,
             sharepoint_tenant_name=self.sharepoint_tenant_name,
         )
-        controller = UpdateThiesDataController(UpdateThiesDataControllerInput(config))
+        controller = UpdateThiesDataController(
+            UpdateThiesDataControllerInput(
+                config, sharepoint_folders_path, ftp_server_folders_path
+            )
+        )
         response = await controller.execute()
         return response.__dict__
 
     async def upload_backup_to_sharepoint(
-        self, local_backup_source_path: str, destination_folders: dict[str, str]
+        self, local_backup_source_path: str, sharepoint_destination_path: str
     ) -> Dict[str, Any]:
         """Migrate a backup folder from Home assistant to Sharepoint directory.
         Args:
@@ -70,13 +80,13 @@ class EpiiAPI:
             sharepoint_site_name=self.sharepoint_site_name,
             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,
             logger=self.logger,
         )
 
         controller = UploadBackupToSharepointController(
-            UploadBackupToSharepointControllerInput(config)
+            UploadBackupToSharepointControllerInput(
+                config, local_backup_source_path, sharepoint_destination_path
+            )
         )
         response = await controller.execute()
         return response.__dict__

{saviialib-0.10.2 → saviialib-0.11.0}/src/saviialib/services/epii/controllers/types/update_thies_data_types.py

@@ -8,6 +8,8 @@ from saviialib.general_types.api.epii_api_types import (
 @dataclass
 class UpdateThiesDataControllerInput:
     config: EpiiUpdateThiesConfig
+    sharepoint_folders_path: list
+    ftp_server_folders_path: list
 
 
 @dataclass

{saviialib-0.10.2 → saviialib-0.11.0}/src/saviialib/services/epii/controllers/types/upload_backup_to_sharepoint_types.py

@@ -7,6 +7,8 @@ from saviialib.general_types.api.epii_api_types import EpiiSharepointBackupConfi
 @dataclass
 class UploadBackupToSharepointControllerInput:
     config: EpiiSharepointBackupConfig
+    local_backup_source_path: str
+    sharepoint_destination_path: str
 
 
 @dataclass

{saviialib-0.10.2 → saviialib-0.11.0}/src/saviialib/services/epii/controllers/update_thies_data.py

@@ -5,6 +5,7 @@ from saviialib.general_types.error_types.api.epii_api_error_types import (
     ThiesConnectionError,
     ThiesFetchingError,
     SharePointUploadError,
+    SharePointDirectoryError,
 )
 from saviialib.general_types.error_types.common.common_types import (
     EmptyDataError,
@@ -42,6 +43,8 @@ class UpdateThiesDataController:
                     sharepoint_tenant_name=input.config.sharepoint_tenant_name,
                     sharepoint_tenant_id=input.config.sharepoint_tenant_id,
                 ),
+                sharepoint_folders_path=input.sharepoint_folders_path,
+                ftp_server_folders_path=input.ftp_server_folders_path,
             )
         )
 
@@ -51,7 +54,7 @@ class UpdateThiesDataController:
             return UpdateThiesDataControllerOutput(
                 message="THIES was synced successfully",
                 status=HTTPStatus.OK.value,
-                metadata={"data": data},
+                metadata={"data": data},  # type: ignore
             )
         except EmptyDataError:
             return UpdateThiesDataControllerOutput(
@@ -87,7 +90,14 @@ class UpdateThiesDataController:
 
         except SharePointUploadError as error:
             return UpdateThiesDataControllerOutput(
-                message="An error oucrred while uploading files to RCER Cloud",
+                message="An error ocurred while uploading files to RCER Cloud",
+                status=HTTPStatus.BAD_REQUEST.value,
+                metadata={"error": error.__str__()},
+            )
+
+        except SharePointDirectoryError as error:
+            return UpdateThiesDataControllerOutput(
+                message="An error ocurred while extracting folders from Microsoft Sharepoint",
                 status=HTTPStatus.BAD_REQUEST.value,
                 metadata={"error": error.__str__()},
             )

{saviialib-0.10.2 → saviialib-0.11.0}/src/saviialib/services/epii/controllers/upload_backup_to_sharepoint.py

@@ -33,8 +33,8 @@ class UploadBackupToSharepointController:
                     sharepoint_tenant_name=input.config.sharepoint_tenant_name,
                     sharepoint_tenant_id=input.config.sharepoint_tenant_id,
                 ),
-                local_backup_source_path=input.config.local_backup_source_path,
-                destination_folders=input.config.destination_folders,
+                local_backup_source_path=input.local_backup_source_path,
+                sharepoint_destination_path=input.sharepoint_destination_path,
                 logger=input.config.logger,
             )
         )
@@ -45,7 +45,7 @@ class UploadBackupToSharepointController:
             return UploadBackupToSharepointControllerOutput(
                 message="Local backup was migrated successfully",
                 status=HTTPStatus.OK.value,
-                metadata={"data": data},
+                metadata={"data": data},  # type: ignore
             )
         except EmptyDataError:
             return UploadBackupToSharepointControllerOutput(

saviialib-0.11.0/src/saviialib/services/epii/use_cases/constants/upload_backup_to_sharepoint_constants.py

@@ -0,0 +1,5 @@
+import logging
+
+
+logging.basicConfig(level=logging.DEBUG)
+LOGGER = logging.getLogger(__package__)

{saviialib-0.10.2 → saviialib-0.11.0}/src/saviialib/services/epii/use_cases/types/update_thies_data_types.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import Dict
+from typing import Dict, List
 from saviialib.general_types.api.epii_api_types import FtpClientConfig, SharepointConfig
 
 
@@ -7,6 +7,8 @@ from saviialib.general_types.api.epii_api_types import FtpClientConfig, Sharepoi
 class UpdateThiesDataUseCaseInput:
     ftp_config: FtpClientConfig
     sharepoint_config: SharepointConfig
+    sharepoint_folders_path: List
+    ftp_server_folders_path: List
 
 
 @dataclass

{saviialib-0.10.2 → saviialib-0.11.0}/src/saviialib/services/epii/use_cases/types/upload_backup_to_sharepoint_types.py

@@ -7,5 +7,5 @@ from logging import Logger
 class UploadBackupToSharepointUseCaseInput:
     sharepoint_config: SharepointConfig
     local_backup_source_path: str
-    destination_folders: dict
+    sharepoint_destination_path: str
     logger: Logger

{saviialib-0.10.2 → saviialib-0.11.0}/src/saviialib/services/epii/use_cases/update_thies_data.py

@@ -1,6 +1,6 @@
-import saviialib.services.epii.use_cases.constants.update_thies_data_constants as c
 from saviialib.general_types.error_types.api.epii_api_error_types import (
     SharePointFetchingError,
+    SharePointDirectoryError,
     SharePointUploadError,
     ThiesConnectionError,
     ThiesFetchingError,
@@ -20,6 +20,7 @@ from saviialib.libs.sharepoint_client import (
     SharepointClient,
     SharepointClientInitArgs,
     SpListFilesArgs,
+    SpListFoldersArgs,
     SpUploadFileArgs,
 )
 from saviialib.services.epii.use_cases.types import (
@@ -38,6 +39,9 @@ class UpdateThiesDataUseCase:
             input.sharepoint_config
         )
         self.thies_ftp_client = self._initialize_thies_ftp_client(input.ftp_config)
+        self.sharepoint_folders_path = input.sharepoint_folders_path
+        self.ftp_server_folders_path = input.ftp_server_folders_path
+        self.sharepoint_base_url = f"/sites/{self.sharepoint_client.site_name}"
         self.uploading = set()
 
     def _initialize_sharepoint_client(
@@ -58,36 +62,56 @@ class UpdateThiesDataUseCase:
         except RuntimeError as error:
             raise FtpClientError(error)
 
+    async def _validate_sharepoint_current_folders(self):
+        async with self.sharepoint_client:
+            folder_base_path = "/".join(
+                self.sharepoint_folders_path[0].split("/")[0:-1]
+            )
+            relative_url = f"{self.sharepoint_base_url}/{folder_base_path}"
+            response = await self.sharepoint_client.list_folders(
+                SpListFoldersArgs(relative_url)
+            )
+
+        current_folders = [item["Name"] for item in response["value"]]  # type: ignore
+
+        for folder_path in self.sharepoint_folders_path:
+            folder_name = folder_path.split("/")[-1]
+            if folder_name not in current_folders:
+                raise SharePointDirectoryError(
+                    reason=f"The current folder '{folder_name}' doesn't exist."
+                )
+
     async def fetch_cloud_file_names(self) -> set[str]:
         """Fetch file names from the RCER cloud."""
-
+        await self._validate_sharepoint_current_folders()
         try:
             cloud_files = set()
             async with self.sharepoint_client:
-                for folder in c.SHAREPOINT_THIES_FOLDERS:
-                    args = SpListFilesArgs(
-                        folder_relative_url=f"{c.SHAREPOINT_BASE_URL}/{folder}"
-                    )
+                for folder_path in self.sharepoint_folders_path:
+                    folder_name = folder_path.split("/")[-1]
+                    relative_url = f"{self.sharepoint_base_url}/{folder_path}"
+                    args = SpListFilesArgs(folder_relative_url=relative_url)
                     response = await self.sharepoint_client.list_files(args)
                     cloud_files.update(
-                        {f"{folder}_{item['Name']}" for item in response["value"]}
+                        {f"{folder_name}_{item['Name']}" for item in response["value"]}  # type: ignore
                     )
             return cloud_files
-        except ConnectionError as error:
+        except Exception as error:
             raise SharePointFetchingError(reason=error)
 
     async def fetch_thies_file_names(self) -> set[str]:
         """Fetch file names from the THIES FTP server."""
         try:
-            avg_files = await self.thies_ftp_client.list_files(
-                FtpListFilesArgs(path=c.FTP_SERVER_PATH_AVG_FILES)
-            )
-            ext_files = await self.thies_ftp_client.list_files(
-                FtpListFilesArgs(path=c.FTP_SERVER_PATH_EXT_FILES)
-            )
-            return {f"AVG_{name}" for name in avg_files} | {
-                f"EXT_{name}" for name in ext_files
-            }
+            thies_files = set()
+            for folder_path in self.ftp_server_folders_path:
+                # AV for average, and EXT for extreme.
+                prefix = "AVG" if "AV" in folder_path else "EXT"
+                files = await self.thies_ftp_client.list_files(
+                    FtpListFilesArgs(path=folder_path)
+                )
+                files_names = {f"{prefix}_{name}" for name in files}
+                thies_files.update(files_names)
+            return thies_files
         except ConnectionRefusedError as error:
             raise ThiesConnectionError(reason=error)
         except ConnectionAbortedError as error:
@@ -98,16 +122,19 @@ class UpdateThiesDataUseCase:
         try:
             content_files = {}
             for file in self.uploading:
-                origin, filename = file.split("_", 1)
-                file_path = (
-                    f"{c.FTP_SERVER_PATH_AVG_FILES}/{filename}"
-                    if origin == "AVG"
-                    else f"{c.FTP_SERVER_PATH_EXT_FILES}/{filename}"
+                _, filename = file.split("_", 1)
+                folder_path = (
+                    self.ftp_server_folders_path[0]
+                    if "AV" in self.ftp_server_folders_path[0]  # Folder with AVG prefix
+                    else self.ftp_server_folders_path[1]  # Folder with EXT prefix
                 )
+                file_path = f"{folder_path}/{filename}"
                 content = await self.thies_ftp_client.read_file(
                     FtpReadFileArgs(file_path)
                 )
-                content_files[file] = content  # Save the file with its prefix
+                content_files[file] = (
+                    content  # Save file content with its original name.
+                )
             return content_files
         except ConnectionRefusedError as error:
             raise ThiesConnectionError(reason=error)
@@ -123,9 +150,16 @@ class UpdateThiesDataUseCase:
         async with self.sharepoint_client:
             for file, file_content in files.items():
                 try:
-                    folder, file_name = file.split("_", 1)
+                    _, file_name = file.split("_", 1)
+                    # Could be AVG or EXT.
+                    if file_name in self.sharepoint_folders_path[0]:
+                        folder_path = self.sharepoint_folders_path[0]
+                    else:
+                        folder_path = self.sharepoint_folders_path[1]
+                    relative_url = f"{self.sharepoint_base_url}/{folder_path}"
+
                     args = SpUploadFileArgs(
-                        folder_relative_url=f"{c.SHAREPOINT_BASE_URL}/{folder}",
+                        folder_relative_url=relative_url,
                         file_content=file_content,
                         file_name=file_name,
                     )
@@ -145,16 +179,17 @@ class UpdateThiesDataUseCase:
 
         return upload_results
 
-    async def execute(self) -> dict:
+    async def execute(self):
         """Synchronize data from the THIES Center to the cloud."""
         try:
             thies_files = await self.fetch_thies_file_names()
         except RuntimeError as error:
             raise FtpClientError(error)
+
         try:
             cloud_files = await self.fetch_cloud_file_names()
         except RuntimeError as error:
-            raise SharepointClient(error)
+            raise SharepointClient(error)  # type: ignore
 
         self.uploading = thies_files - cloud_files
         if not self.uploading:
@@ -168,4 +203,4 @@ class UpdateThiesDataUseCase:
             thies_fetched_files
         )
 
-        return parse_execute_response(thies_fetched_files, upload_statistics)
+        return parse_execute_response(thies_fetched_files, upload_statistics)  # type: ignore

{saviialib-0.10.2 → saviialib-0.11.0}/src/saviialib/services/epii/use_cases/upload_backup_to_sharepoint.py

@@ -1,7 +1,6 @@
 import asyncio
 from time import time
 from logging import Logger
-import saviialib.services.epii.use_cases.constants.upload_backup_to_sharepoint_constants as c
 from saviialib.general_types.error_types.api.epii_api_error_types import (
     BackupEmptyError,
     BackupSourcePathError,
@@ -21,6 +20,7 @@ from saviialib.libs.sharepoint_client import (
     SharepointClient,
     SharepointClientInitArgs,
     SpUploadFileArgs,
+    SpListFoldersArgs,
 )
 from saviialib.services.epii.utils.upload_backup_to_sharepoint_utils import (
     calculate_percentage_uploaded,
@@ -39,13 +39,21 @@ class UploadBackupToSharepointUsecase:
     def __init__(self, input: UploadBackupToSharepointUseCaseInput):
         self.sharepoint_config = input.sharepoint_config
         self.local_backup_source_path = input.local_backup_source_path
-        self.destination_folders = input.destination_folders
+        self.sharepoint_destination_path = input.sharepoint_destination_path
         self.files_client = self._initialize_files_client()
         self.dir_client = self._initialize_directory_client()
         self.log_history = []
         self.grouped_files_by_folder = None
         self.total_files = None
         self.logger: Logger = input.logger
+        self.sharepoint_client = self._initalize_sharepoint_client()
+
+    def _initalize_sharepoint_client(self):
+        return SharepointClient(
+            SharepointClientInitArgs(
+                self.sharepoint_config, client_name="sharepoint_rest_api"
+            )
+        )
 
     def _initialize_directory_client(self):
         return DirectoryClient(DirectoryClientArgs(client_name="os_client"))
@@ -53,7 +61,44 @@ class UploadBackupToSharepointUsecase:
     def _initialize_files_client(self):
         return FilesClient(FilesClientInitArgs(client_name="aiofiles_client"))
 
-    async def _extract_filesnames_by_folder(self) -> dict[str, list[str]]:
+    async def _validate_backup_structure(self):
+        # Check if the local path exists in the main directory
+        if not await self.dir_client.path_exists(self.local_backup_source_path):
+            raise BackupSourcePathError(
+                reason=f"'{self.local_backup_source_path}' doesn't exist."
+            )
+
+        local_directories = (
+            list(self.grouped_files_by_folder.keys())
+            if self.grouped_files_by_folder
+            else []
+        )
+        async with self.sharepoint_client:  # type: ignore
+            response = await self.sharepoint_client.list_folders(
+                SpListFoldersArgs(folder_relative_url=self.sharepoint_destination_path)
+            )
+            sharepoint_directories = [x["Name"] for x in response["value"]]  # type: ignore
+
+        # Verify that all local directories exist in SharePoint
+        for local_dir in local_directories:
+            if local_dir not in sharepoint_directories:
+                error_message = f"Folder '{local_dir}' does not exist in SharePoint destination path '{self.sharepoint_destination_path}'."
+                self.log_history.append(error_message)
+                self.logger.error("[local_backup_lib] %s", error_message)
+                raise BackupSourcePathError(
+                    reason=f"Folder '{local_dir}' does not exist in SharePoint destination path '{self.sharepoint_destination_path}'."
+                )
+
+        # Check if the current folder only have files and each folder exist in Microsoft Sharepoint.
+        if self.total_files == 0:
+            no_files_message = (
+                f"[local_backup_lib] {self.local_backup_source_path} has no files ⚠️"
+            )
+            self.log_history.append(no_files_message)
+            self.logger.debug(no_files_message)
+            raise BackupEmptyError
+
+    async def _group_files_by_folder(self) -> dict[str, list[str]]:
         """Groups files by their parent folder."""
         backup_folder_exists = await self.dir_client.path_exists(
             self.local_backup_source_path
@@ -62,17 +107,17 @@ class UploadBackupToSharepointUsecase:
         if not backup_folder_exists:
             return {}
         folder_names = await self.dir_client.listdir(self.local_backup_source_path)
-        return {
-            folder_name: [
-                file_name
-                for file_name in await self.dir_client.listdir(
-                    self.dir_client.join_paths(
-                        self.local_backup_source_path, folder_name
-                    )
-                )
-            ]
-            for folder_name in folder_names
-        }
+        grouped = {}
+        for folder_name in folder_names:
+            is_folder = await self.dir_client.isdir(
+                self.dir_client.join_paths(self.local_backup_source_path, folder_name)
+            )
+            if not is_folder:
+                continue
+            grouped[folder_name] = await self.dir_client.listdir(
+                self.dir_client.join_paths(self.local_backup_source_path, folder_name)
+            )
+        return grouped
 
     async def _save_log_history(self) -> None:
         await self.files_client.write(
@@ -83,6 +128,30 @@ class UploadBackupToSharepointUsecase:
             )
         )
 
+    async def _generate_tasks(self) -> list:
+        tasks = []
+        for folder_name in self.grouped_files_by_folder:  # type: ignore
+            count_files_in_dir = await count_files_in_directory(
+                self.local_backup_source_path, folder_name
+            )
+            if count_files_in_dir == 0:
+                empty_folder_message = (
+                    f"[local_backup_lib] The folder '{folder_name}' is empty ⚠️"
+                )
+                self.logger.debug(empty_folder_message)
+                self.log_history.append(empty_folder_message)
+                continue
+            extracting_files_message = (
+                "[local_backup_lib]"
+                + f" Extracting files from '{folder_name} ".center(15, "*")
+            )
+            self.log_history.append(extracting_files_message)
+            self.logger.debug(extracting_files_message)
+            for file_name in self.grouped_files_by_folder[folder_name]:  # type: ignore
+                tasks.append(self._upload_and_log_progress_task(folder_name, file_name))
+
+        return tasks
+
     async def export_file_to_sharepoint(
         self, folder_name: str, file_name: str, file_content: bytes
     ) -> tuple[bool, str]:
@@ -101,10 +170,7 @@ class UploadBackupToSharepointUsecase:
 
         async with sharepoint_client:
             try:
-                destination_folder = self.destination_folders.get(
-                    folder_name, folder_name
-                )
-                folder_url = f"{c.SHAREPOINT_BASE_URL}/{destination_folder}"
+                folder_url = f"{self.sharepoint_destination_path}/{folder_name}"
                 args = SpUploadFileArgs(
                     folder_relative_url=folder_url,
                     file_content=file_content,
@@ -130,7 +196,9 @@ class UploadBackupToSharepointUsecase:
         )
         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
+            folder_name,
+            file_name,
+            file_content,  # type: ignore
         )
         result_message = show_upload_result(uploaded, file_name)
         self.logger.debug(result_message)
@@ -155,10 +223,10 @@ class UploadBackupToSharepointUsecase:
                 )
             )
         results = await asyncio.gather(*tasks, return_exceptions=True)
-        success = calculate_percentage_uploaded(results, self.total_files)
+        success = calculate_percentage_uploaded(results, self.total_files)  # type: ignore
         if success < 100.0:
             raise BackupUploadError(
-                reason=extract_error_message(self.logger, results, success)
+                reason=extract_error_message(self.logger, results, success)  # type: ignore
             )
         else:
             successful_upload_retry = (
@@ -167,77 +235,26 @@ class UploadBackupToSharepointUsecase:
             self.log_history.append(successful_upload_retry)
             self.logger.debug(successful_upload_retry)
             await self._save_log_history()
-            return parse_execute_response(results)
+            return parse_execute_response(results)  # type: ignore
 
     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()
+        start_time = time()
+        self.grouped_files_by_folder = await self._group_files_by_folder()
         self.total_files = sum(
             len(files) for files in self.grouped_files_by_folder.values()
         )
-        tasks = []
-        start_time = time()
 
-        # Check if the local path exists in the main directory
-        if not await self.dir_client.path_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 self.dir_client.listdir(self.local_backup_source_path)
-        ]
-        for item in items:
-            folder_included = item in self.destination_folders.keys()
-            is_file = not await self.dir_client.isdir(
-                self.dir_client.join_paths(self.local_backup_source_path, item)
-            )
+        # Check if the current folder only have files and each folder exist in Microsoft Sharepoint.
+        await self._validate_backup_structure()
 
-            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"[local_backup_lib] {self.local_backup_source_path} has no files ⚠️"
-            )
-            self.log_history.append(no_files_message)
-            self.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 (
-                await count_files_in_directory(
-                    self.local_backup_source_path, folder_name
-                )
-                == 0
-            ):
-                empty_folder_message = (
-                    f"[local_backup_lib] The folder '{folder_name}' is empty ⚠️"
-                )
-                self.logger.debug(empty_folder_message)
-                self.log_history.append(empty_folder_message)
-                continue
-            extracting_files_message = (
-                "[local_backup_lib]"
-                + f" Extracting files from '{folder_name} ".center(15, "*")
-            )
-            self.log_history.append(extracting_files_message)
-            self.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))
+        tasks = await self._generate_tasks()
 
         # Execution of multiple asynchronous tasks for files migration.
         results = await asyncio.gather(*tasks, return_exceptions=True)
-        success = calculate_percentage_uploaded(results, self.total_files)
+        success = calculate_percentage_uploaded(results, self.total_files)  # type: ignore
+
         if success < 100.0:
             await self.retry_upload_failed_files(results)
         else:
@@ -254,4 +271,4 @@ class UploadBackupToSharepointUsecase:
             self.log_history.append(finished_backup_message)
 
             await self._save_log_history()
-            return parse_execute_response(results)
+            return parse_execute_response(results)  # type: ignore

saviialib-0.10.2/src/saviialib/services/epii/use_cases/constants/update_thies_data_constants.py

@@ -1,5 +0,0 @@
-SHAREPOINT_BASE_URL = "/sites/uc365_CentrosyEstacionesRegionalesUC/Shared%20Documents/General/Test_Raspberry/THIES"
-SHAREPOINT_THIES_FOLDERS = ["AVG", "EXT"]
-
-FTP_SERVER_PATH_AVG_FILES = "ftp/thies/BINFILES/ARCH_AV1"
-FTP_SERVER_PATH_EXT_FILES = "ftp/thies/BINFILES/ARCH_EX1"

saviialib-0.10.2/src/saviialib/services/epii/use_cases/constants/upload_backup_to_sharepoint_constants.py

@@ -1,6 +0,0 @@
-import logging
-
-SHAREPOINT_BASE_URL = "/sites/uc365_CentrosyEstacionesRegionalesUC/Shared%20Documents/General/Test_Raspberry"
-
-logging.basicConfig(level=logging.DEBUG)
-LOGGER = logging.getLogger(__package__)