saviialib 0.9.0__tar.gz → 0.10.1__tar.gz

{saviialib-0.9.0 → saviialib-0.10.1}/PKG-INFO

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

{saviialib-0.9.0 → saviialib-0.10.1}/pyproject.toml

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

{saviialib-0.9.0 → saviialib-0.10.1}/src/saviialib/general_types/api/epii_api_types.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from logging import Logger
 
 
 @dataclass
@@ -27,6 +28,7 @@ class EpiiAPIConfig:
     sharepoint_tenant_id: str
     sharepoint_tenant_name: str
     sharepoint_site_name: str
+    logger: Logger
 
 
 @dataclass
@@ -80,3 +82,4 @@ class EpiiSharepointBackupConfig:
     sharepoint_site_name: str
     local_backup_source_path: str
     destination_folders: str
+    logger: Logger

saviialib-0.10.1/src/saviialib/libs/directory_client/__init__.py

@@ -0,0 +1,4 @@
+from .directory_client import DirectoryClient
+from .types.directory_client_types import DirectoryClientArgs
+
+__all__ = ["DirectoryClient", "DirectoryClientArgs"]

saviialib-0.10.1/src/saviialib/libs/directory_client/client/os_client.py

@@ -0,0 +1,23 @@
+from saviialib.libs.directory_client.directory_client_contract import (
+    DirectoryClientContract,
+)
+import os
+import asyncio
+
+
+class OsClient(DirectoryClientContract):
+    @staticmethod
+    def join_paths(*paths: str) -> str:
+        return os.path.join(*paths)
+
+    @staticmethod
+    async def path_exists(path: str) -> bool:
+        return await asyncio.to_thread(os.path.exists, path)
+
+    @staticmethod
+    async def listdir(path: str) -> list:
+        return await asyncio.to_thread(os.listdir, path)
+
+    @staticmethod
+    async def isdir(path: str) -> list:
+        return await asyncio.to_thread(os.path.isdir, path)

saviialib-0.10.1/src/saviialib/libs/directory_client/directory_client.py

@@ -0,0 +1,28 @@
+from .client.os_client import OsClient
+from .directory_client_contract import DirectoryClientContract
+from .types.directory_client_types import DirectoryClientArgs
+
+
+class DirectoryClient(DirectoryClientContract):
+    CLIENTS = {"os_client"}
+
+    def __init__(self, args: DirectoryClientArgs) -> None:
+        if args.client_name not in DirectoryClient.CLIENTS:
+            msg = f"Unsupported client {args.client_name}"
+            raise KeyError(msg)
+
+        if args.client_name == "os_client":
+            self.client_obj = OsClient()
+        self.client_name = args.client_name
+
+    def join_paths(self, *paths: str) -> str:
+        return self.client_obj.join_paths(*paths)
+
+    async def path_exists(self, path: str) -> bool:
+        return await self.client_obj.path_exists(path)
+
+    async def listdir(self, path: str) -> list:
+        return await self.client_obj.listdir(path)
+
+    async def isdir(self, path: str) -> bool:
+        return await self.client_obj.isdir(path)

saviialib-0.10.1/src/saviialib/libs/directory_client/directory_client_contract.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+
+
+class DirectoryClientContract(ABC):
+    @abstractmethod
+    def join_paths(self, *paths: str) -> str:
+        pass
+
+    @abstractmethod
+    async def path_exists(self, path: str) -> bool:
+        pass
+
+    @abstractmethod
+    async def listdir(self, path: str) -> list:
+        pass
+
+    @abstractmethod
+    async def isdir(self, path) -> bool:
+        pass

saviialib-0.10.1/src/saviialib/libs/directory_client/types/directory_client_types.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class DirectoryClientArgs:
+    client_name: str = "os_client"

{saviialib-0.9.0 → saviialib-0.10.1}/src/saviialib/libs/files_client/__init__.py

@@ -1,4 +1,4 @@
 from .files_client import FilesClient
-from .types.files_client_types import FilesClientInitArgs, ReadArgs
+from .types.files_client_types import FilesClientInitArgs, ReadArgs, WriteArgs
 
-__all__ = ["FilesClient", "FilesClientInitArgs", "ReadArgs"]
+__all__ = ["FilesClient", "FilesClientInitArgs", "ReadArgs", "WriteArgs"]

{saviialib-0.9.0 → saviialib-0.10.1}/src/saviialib/libs/files_client/clients/aiofiles_client.py

@@ -1,5 +1,8 @@
 import aiofiles
-
+from saviialib.libs.directory_client.directory_client import (
+    DirectoryClient,
+    DirectoryClientArgs,
+)
 from saviialib.libs.files_client.files_client_contract import FilesClientContract
 from saviialib.libs.files_client.types.files_client_types import (
     FilesClientInitArgs,
@@ -10,7 +13,7 @@ from saviialib.libs.files_client.types.files_client_types import (
 
 class AioFilesClient(FilesClientContract):
     def __init__(self, args: FilesClientInitArgs):
-        pass
+        self.dir_client = DirectoryClient(DirectoryClientArgs(client_name="os_client"))
 
     async def read(self, args: ReadArgs) -> str | bytes:
         encoding = None if args.mode == "rb" else args.encoding
@@ -18,4 +21,10 @@ class AioFilesClient(FilesClientContract):
             return await file.read()
 
     async def write(self, args: WriteArgs) -> None:
-        return None
+        file_path = (
+            self.dir_client.join_paths(args.destination_path, args.file_name)
+            if args.destination_path
+            else args.file_name
+        )
+        async with aiofiles.open(file_path, args.mode) as file:
+            await file.write(args.file_content)

{saviialib-0.9.0 → saviialib-0.10.1}/src/saviialib/libs/files_client/types/files_client_types.py

@@ -26,6 +26,7 @@ class ReadArgs:
 
 @dataclass
 class WriteArgs:
-    destination_path: str
     file_name: str
     file_content: str | bytes
+    mode: Literal["w", "wb", "a"]
+    destination_path: str = ""

{saviialib-0.9.0 → saviialib-0.10.1}/src/saviialib/services/epii/api.py

@@ -28,6 +28,7 @@ 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]:
         """
@@ -70,7 +71,8 @@ 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
+            destination_folders=destination_folders,
+            logger=self.logger,
         )
 
         controller = UploadBackupToSharepointController(

{saviialib-0.9.0 → saviialib-0.10.1}/src/saviialib/services/epii/controllers/upload_backup_to_sharepoint.py

@@ -34,7 +34,8 @@ 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
+                destination_folders=input.config.destination_folders,
+                logger=input.config.logger,
             )
         )
 

{saviialib-0.9.0 → saviialib-0.10.1}/src/saviialib/services/epii/use_cases/constants/upload_backup_to_sharepoint_constants.py

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

{saviialib-0.9.0 → saviialib-0.10.1}/src/saviialib/services/epii/use_cases/types/upload_backup_to_sharepoint_types.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 from saviialib.general_types.api.epii_api_types import SharepointConfig
+from logging import Logger
 
 
 @dataclass
@@ -7,3 +8,4 @@ class UploadBackupToSharepointUseCaseInput:
     sharepoint_config: SharepointConfig
     local_backup_source_path: str
     destination_folders: dict
+    logger: Logger

{saviialib-0.9.0 → saviialib-0.10.1}/src/saviialib/services/epii/use_cases/upload_backup_to_sharepoint.py

@@ -1,6 +1,6 @@
 import asyncio
-import os
 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,
@@ -10,7 +10,13 @@ from saviialib.general_types.error_types.api.epii_api_error_types import (
 from saviialib.general_types.error_types.common import (
     SharepointClientError,
 )
-from saviialib.libs.files_client import FilesClient, FilesClientInitArgs, ReadArgs
+from saviialib.libs.directory_client import DirectoryClient, DirectoryClientArgs
+from saviialib.libs.files_client import (
+    FilesClient,
+    FilesClientInitArgs,
+    ReadArgs,
+    WriteArgs,
+)
 from saviialib.libs.sharepoint_client import (
     SharepointClient,
     SharepointClientInitArgs,
@@ -19,7 +25,6 @@ from saviialib.libs.sharepoint_client import (
 from saviialib.services.epii.utils.upload_backup_to_sharepoint_utils import (
     calculate_percentage_uploaded,
     count_files_in_directory,
-    directory_exists,
     extract_error_message,
     parse_execute_response,
     show_upload_result,
@@ -28,7 +33,6 @@ 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:
@@ -36,35 +40,48 @@ class UploadBackupToSharepointUsecase:
         self.sharepoint_config = input.sharepoint_config
         self.local_backup_source_path = input.local_backup_source_path
         self.destination_folders = input.destination_folders
-        self.grouped_files_by_folder = self._extract_filesnames_by_folder()
         self.files_client = self._initialize_files_client()
-        self.total_files = sum(
-            len(files) for files in self.grouped_files_by_folder.values()
-        )
+        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
+
+    def _initialize_directory_client(self):
+        return DirectoryClient(DirectoryClientArgs(client_name="os_client"))
 
     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 self.dir_client.path_exists(
+            self.local_backup_source_path
+        )
+
+        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 os.listdir(
-                    os.path.join(self.local_backup_source_path, folder_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 os.listdir(self.local_backup_source_path)
+            for folder_name in folder_names
         }
 
-    def _save_log_history(self) -> None:
-        text_file = "\n".join(self.log_history)
-        log_history_filepath = "BACKUP_LOG_HISTORY.log"
-        with open(log_history_filepath, "w") as file:
-            file.write(text_file)
+    async def _save_log_history(self) -> None:
+        await self.files_client.write(
+            WriteArgs(
+                file_name="BACKUP_LOG_HISTORY.log",
+                file_content="\n".join(self.log_history),
+                mode="w",
+            )
+        )
 
     async def export_file_to_sharepoint(
         self, folder_name: str, file_name: str, file_content: bytes
@@ -84,7 +101,9 @@ class UploadBackupToSharepointUsecase:
 
         async with sharepoint_client:
             try:
-                destination_folder = self.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,
@@ -99,20 +118,22 @@ class UploadBackupToSharepointUsecase:
 
         return uploaded, error_message
 
-    async def upload_and_log_progress_task(self, folder_name, file_name) -> dict:
+    async def _upload_and_log_progress_task(self, folder_name, file_name) -> dict:
         """Task for uploads a file and logs progress."""
         uploading_message = (
             f"[BACKUP] Uploading file '{file_name}' from '{folder_name}' "
         )
         self.log_history.append(uploading_message)
-        LOGGER.debug(uploading_message)
-        file_path = os.path.join(self.local_backup_source_path, folder_name, file_name)
+        self.logger.debug(uploading_message)
+        file_path = self.dir_client.join_paths(
+            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)
-        LOGGER.debug(result_message)
+        self.logger.debug(result_message)
         self.log_history.append(result_message)
         return {
             "parent_folder": folder_name,
@@ -128,42 +149,55 @@ class UploadBackupToSharepointUsecase:
             f"[BACKUP] Retrying upload for {len(failed_files)} failed files... 🚨"
         )
         self.log_history.append(retry_message)
-        LOGGER.debug(retry_message)
+        self.logger.debug(retry_message)
         for file in failed_files:
             tasks.append(
-                self.upload_and_log_progress_task(
+                self._upload_and_log_progress_task(
                     file["parent_folder"], file["file_name"]
                 )
             )
         results = await asyncio.gather(*tasks, return_exceptions=True)
         success = calculate_percentage_uploaded(results, self.total_files)
         if success < 100.0:
-            raise BackupUploadError(reason=extract_error_message(results, success))
+            raise BackupUploadError(
+                reason=extract_error_message(self.logger, results, success)
+            )
         else:
             successful_upload_retry = (
                 "[BACKUP] All files uploaded successfully after retry."
             )
             self.log_history.append(successful_upload_retry)
-            LOGGER.debug(successful_upload_retry)
-            self._save_log_history()
+            self.logger.debug(successful_upload_retry)
+            await 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()
-        
+
         # Check if the local path exists in the main directory
-        if not directory_exists(self.local_backup_source_path):
+        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.
-        for item in os.listdir(self.local_backup_source_path):
+        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 os.path.isdir(os.path.join(self.local_backup_source_path, item))
-            if not folder_included and not is_file: 
+            is_file = not await self.dir_client.isdir(
+                self.dir_client.join_paths(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",
@@ -171,36 +205,34 @@ class UploadBackupToSharepointUsecase:
                 )
             elif folder_included and is_file:
                 print(folder_included, is_file)
-                raise BackupSourcePathError(
-                    reason=(
-                        f"'{item}' must be a directory.",
-                    )
-                )
-            
+                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)
-            LOGGER.debug(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 (
-                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 ⚠️"
-                LOGGER.debug(empty_folder_message)
+                self.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)
-            LOGGER.debug(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.append(self._upload_and_log_progress_task(folder_name, file_name))
 
         # Execution of multiple asynchronous tasks for files migration.
         results = await asyncio.gather(*tasks, return_exceptions=True)
@@ -220,5 +252,5 @@ class UploadBackupToSharepointUsecase:
             )
             self.log_history.append(finished_backup_message)
 
-            self._save_log_history()
+            await self._save_log_history()
             return parse_execute_response(results)

{saviialib-0.9.0 → saviialib-0.10.1}/src/saviialib/services/epii/utils/upload_backup_to_sharepoint_utils.py

@@ -1,12 +1,12 @@
 import re
+from logging import Logger
 from typing import List, Dict, Optional
-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,
-)
+from saviialib.libs.directory_client import DirectoryClient, DirectoryClientArgs
+
+dir_client = DirectoryClient(DirectoryClientArgs(client_name="os_client"))
 
 
 def extract_error_information(error: str) -> Optional[Dict[str, str]]:
@@ -29,8 +29,8 @@ def explain_status_code(status_code: int) -> str:
     return explanations.get(status_code, "Unknown error occurred.")
 
 
-def extract_error_message(results: List[Dict], success: float) -> str:
-    LOGGER.info(
+def extract_error_message(logger: Logger, results: List[Dict], success: float) -> str:
+    logger.info(
         "[BACKUP] Not all files uploaded ⚠️\n"
         f"[BACKUP] Files failed to upload: {(1 - success):.2%}"
     )
@@ -58,9 +58,9 @@ def extract_error_message(results: List[Dict], success: float) -> str:
 
     # Summary
     for code, items in grouped_errors.items():
-        LOGGER.info(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:
-            LOGGER.info(
+            logger.info(
                 f"[BACKUP] File {item['file_name']}, url: {item['url']}, message: {item['message']}"
             )
 
@@ -93,9 +93,5 @@ 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)
-
-
-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 dir_client.listdir(dir_client.join_paths(path, folder_name)))