saviialib 0.6.2__tar.gz → 0.8.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: saviialib
-Version: 0.6.2
+Version: 0.8.0
 Summary: A client library for IoT projects in the RCER initiative
 License: MIT
 Author: pedropablozavalat
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: aiofiles (==24.1.0)
 Requires-Dist: aioftp (==0.25.1)
 Requires-Dist: aiohttp (==3.11.16)
 Requires-Dist: build
@@ -34,23 +35,11 @@ pip install saviialib
 ## Usage
 
 ### Initialize the EPii API Client
-To start using the library, you need to create an `EpiiAPI` client instance:
+To start using the library, you need to create an `EpiiAPI` client instance with its configuration class:
 
 ```python
-from saviialib import EpiiAPI
-
-api_client = EpiiAPI()
-```
-
-### Update THIES Data Logger Files
-The library provides a method to synchronize THIES Data Logger files with the RCER SharePoint client. This method updates the folder containing binary files with meteorological data:
-
-```python
-from saviialib import EpiiUpdateThiesConfig
-import asyncio
-
-async def update_thies_data():
-    config = EpiiUpdateThiesConfig(
+from saviialib import EpiiAPI, EpiiAPIConfig
+config = EpiiAPIConfig(
         ftp_port=FTP_PORT,
         ftp_host=FTP_HOST,
         ftp_user=FTP_USER,
@@ -61,15 +50,26 @@ async def update_thies_data():
         sharepoint_tenant_name=SHAREPOINT_TENANT_NAME,
         sharepoint_site_name=SHAREPOINT_SITE_NAME
     )
-    response = await api_client.update_thies_data(config)
-    return response
-
-asyncio.run(update_thies_data())
+api_client = EpiiAPI(config)
 ```
-
 **Notes:** 
 - Store sensitive data like `FTP_PASSWORD`, `FTP_USER`, and SharePoint credentials securely. Use environment variables or a secrets management tool to avoid hardcoding sensitive information in your codebase.
 
+### Update THIES Data Logger Files
+The library provides a method to synchronize THIES Data Logger files with the RCER SharePoint client. This method updates the folder containing binary files with meteorological data:
+
+```python
+from saviialib import EpiiUpdateThiesConfig
+import asyncio
+
+async def main():
+    # Before calling this method, you must have initialised the api class ...
+    response = await api_client.update_thies_data()
+    return response
+
+asyncio.run(main())
+```
+
 ## Development
 
 This project includes a `Makefile` to simplify common tasks. Below are the available commands:
@@ -111,9 +111,8 @@ make lint
 This command checks the codebase for linting issues and outputs any problems that need to be addressed.
 
 ## Contributing
-If you're interested in contributing to this project, please follow the contributing guidelines. Contributions are welcome and appreciated!
-
-Interested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.
+If you're interested in contributing to this project, please follow the contributing guidelines. By contributing to this project, you agree to abide by its terms.
+Contributions are welcome and appreciated!
 
 ## License
 

{saviialib-0.6.2 → saviialib-0.8.0}/README.md

@@ -14,23 +14,11 @@ pip install saviialib
 ## Usage
 
 ### Initialize the EPii API Client
-To start using the library, you need to create an `EpiiAPI` client instance:
+To start using the library, you need to create an `EpiiAPI` client instance with its configuration class:
 
 ```python
-from saviialib import EpiiAPI
-
-api_client = EpiiAPI()
-```
-
-### Update THIES Data Logger Files
-The library provides a method to synchronize THIES Data Logger files with the RCER SharePoint client. This method updates the folder containing binary files with meteorological data:
-
-```python
-from saviialib import EpiiUpdateThiesConfig
-import asyncio
-
-async def update_thies_data():
-    config = EpiiUpdateThiesConfig(
+from saviialib import EpiiAPI, EpiiAPIConfig
+config = EpiiAPIConfig(
         ftp_port=FTP_PORT,
         ftp_host=FTP_HOST,
         ftp_user=FTP_USER,
@@ -41,15 +29,26 @@ async def update_thies_data():
         sharepoint_tenant_name=SHAREPOINT_TENANT_NAME,
         sharepoint_site_name=SHAREPOINT_SITE_NAME
     )
-    response = await api_client.update_thies_data(config)
-    return response
-
-asyncio.run(update_thies_data())
+api_client = EpiiAPI(config)
 ```
-
 **Notes:** 
 - Store sensitive data like `FTP_PASSWORD`, `FTP_USER`, and SharePoint credentials securely. Use environment variables or a secrets management tool to avoid hardcoding sensitive information in your codebase.
 
+### Update THIES Data Logger Files
+The library provides a method to synchronize THIES Data Logger files with the RCER SharePoint client. This method updates the folder containing binary files with meteorological data:
+
+```python
+from saviialib import EpiiUpdateThiesConfig
+import asyncio
+
+async def main():
+    # Before calling this method, you must have initialised the api class ...
+    response = await api_client.update_thies_data()
+    return response
+
+asyncio.run(main())
+```
+
 ## Development
 
 This project includes a `Makefile` to simplify common tasks. Below are the available commands:
@@ -91,9 +90,8 @@ make lint
 This command checks the codebase for linting issues and outputs any problems that need to be addressed.
 
 ## Contributing
-If you're interested in contributing to this project, please follow the contributing guidelines. Contributions are welcome and appreciated!
-
-Interested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.
+If you're interested in contributing to this project, please follow the contributing guidelines. By contributing to this project, you agree to abide by its terms.
+Contributions are welcome and appreciated!
 
 ## License
 

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "saviialib"
-version = "0.6.2"
+version = "0.8.0"
 description = "A client library for IoT projects in the RCER initiative"
 authors = ["pedropablozavalat"]
 license = "MIT"
@@ -10,6 +10,7 @@ readme = "README.md"
 python = "^3.10"
 aioftp = "0.25.1"
 aiohttp = "3.11.16"
+aiofiles = "24.1.0"
 dotenv = "0.9.9"
 pytest-cov="6.1.1"
 build="*"

{saviialib-0.6.2 → saviialib-0.8.0}/src/saviialib/__init__.py

@@ -4,6 +4,6 @@ from importlib.metadata import version
 __version__ = version("saviialib")
 
 from .services.epii.api import EpiiAPI
-from .general_types.api.update_thies_data_types import EpiiUpdateThiesConfig
+from .general_types.api.epii_api_types import EpiiAPIConfig
 
-__all__ = ["EpiiAPI", "EpiiUpdateThiesConfig"]
+__all__ = ["EpiiAPI", "EpiiAPIConfig"]

saviialib-0.8.0/src/saviialib/general_types/api/__init__.py

@@ -0,0 +1,3 @@
+from .epii_api_types import EpiiUpdateThiesConfig, EpiiSharepointBackupConfig
+
+__all__ = ["EpiiUpdateThiesConfig", "EpiiSharepointBackupConfig"]

saviialib-0.8.0/src/saviialib/general_types/api/epii_api_types.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class EpiiAPIConfig:
+    """
+    Configuration for Epii API.
+
+    Attributes:
+        ftp_port (int): Port number of the FTP server.
+        ftp_host (str): Hostname or IP address of the FTP server.
+        ftp_user (str): Username for the FTP server.
+        ftp_password (str): Password for the FTP server.
+        sharepoint_client_id (str): Client ID for SharePoint authentication.
+        sharepoint_client_secret (str): Client secret for SharePoint authentication.
+        sharepoint_tenant_id (str): Tenant ID for SharePoint authentication.
+        sharepoint_tenant_name (str): Tenant name for SharePoint.
+        sharepoint_site_name (str): Site name in SharePoint.
+    """
+
+    ftp_host: str
+    ftp_port: int
+    ftp_user: str
+    ftp_password: str
+    sharepoint_client_id: str
+    sharepoint_client_secret: str
+    sharepoint_tenant_id: str
+    sharepoint_tenant_name: str
+    sharepoint_site_name: str
+
+
+@dataclass
+class FtpClientConfig:
+    ftp_host: str
+    ftp_port: int
+    ftp_user: str
+    ftp_password: str
+
+
+@dataclass
+class SharepointConfig:
+    sharepoint_client_id: str
+    sharepoint_client_secret: str
+    sharepoint_tenant_id: str
+    sharepoint_tenant_name: str
+    sharepoint_site_name: str
+
+
+@dataclass
+class EpiiUpdateThiesConfig:
+    ftp_port: int
+    ftp_host: str
+    ftp_user: str
+    ftp_password: str
+    sharepoint_client_id: str
+    sharepoint_client_secret: str
+    sharepoint_tenant_id: str
+    sharepoint_tenant_name: str
+    sharepoint_site_name: str
+
+
+@dataclass
+class EpiiSharepointBackupConfig:
+    """
+    Configuration for backing up files to SharePoint.
+
+    Attributes:
+        sharepoint_client_id (str): Client ID for SharePoint authentication.
+        sharepoint_client_secret (str): Client secret for SharePoint authentication.
+        sharepoint_tenant_id (str): Tenant ID for SharePoint authentication.
+        sharepoint_tenant_name (str): Tenant name for SharePoint.
+        sharepoint_site_name (str): Site name in SharePoint.
+        local_backup_source_path (str): Local path to backup.
+    """
+
+    sharepoint_client_id: str
+    sharepoint_client_secret: str
+    sharepoint_tenant_id: str
+    sharepoint_tenant_name: str
+    sharepoint_site_name: str
+    local_backup_source_path: str

saviialib-0.6.2/src/saviialib/general_types/error_types/api/update_thies_data_error_types.py → saviialib-0.8.0/src/saviialib/general_types/error_types/api/epii_api_error_types.py

@@ -55,3 +55,39 @@ class SharePointUploadError(Exception):
             "An error occurred while uploading files to the Microsoft SharePoint folder. "
             + self.reason.__str__()
         )
+
+
+class BackupUploadError(Exception):
+    """Raised when there is an error when occurs the migration from the local backup to
+    sharepoint cloud."""
+
+    def __init__(self, *args, reason):
+        super().__init__(*args, reason)
+        self.reason = reason
+
+    def __str__(self):
+        return (
+            "An error occurred during the migration from the local backup to SharePoint cloud. "
+            "Search the logs for more information. " + self.reason.__str__()
+        )
+
+
+class BackupSourcePathError(Exception):
+    """Raised when the local backup source path is invalid."""
+
+    def __init__(self, *args, reason):
+        super().__init__(*args, reason)
+        self.reason = reason
+
+    def __str__(self):
+        return "Invalid local backup source path. " + self.reason.__str__()
+
+
+class BackupEmptyError(Exception):
+    """Raised when the local backup folder is empty."""
+
+    def __init__(self, *args):
+        super().__init__(*args)
+
+    def __str__(self):
+        return "The local backup folder is empty. "

saviialib-0.8.0/src/saviialib/libs/files_client/__init__.py

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

saviialib-0.8.0/src/saviialib/libs/files_client/clients/aiofiles_client.py

@@ -0,0 +1,21 @@
+import aiofiles
+
+from saviialib.libs.files_client.files_client_contract import FilesClientContract
+from saviialib.libs.files_client.types.files_client_types import (
+    FilesClientInitArgs,
+    ReadArgs,
+    WriteArgs,
+)
+
+
+class AioFilesClient(FilesClientContract):
+    def __init__(self, args: FilesClientInitArgs):
+        pass
+
+    async def read(self, args: ReadArgs) -> str | bytes:
+        encoding = None if args.mode == "rb" else args.encoding
+        async with aiofiles.open(args.file_path, args.mode, encoding=encoding) as file:
+            return await file.read()
+
+    async def write(self, args: WriteArgs) -> None:
+        return None

saviialib-0.8.0/src/saviialib/libs/files_client/files_client.py

@@ -0,0 +1,28 @@
+from .clients.aiofiles_client import AioFilesClient
+from .files_client_contract import FilesClientContract
+from .types.files_client_types import FilesClientInitArgs, ReadArgs, WriteArgs
+
+
+class FilesClient(FilesClientContract):
+    CLIENTS = {"aiofiles_client"}
+
+    def __init__(self, args: FilesClientInitArgs) -> None:
+        if args.client_name not in FilesClient.CLIENTS:
+            msg = f"Unsupported client {args.client_name}"
+            raise KeyError(msg)
+
+        if args.client_name == "aiofiles_client":
+            self.client_obj = AioFilesClient(args)
+        self.client_name = args.client_name
+
+    async def read(self, args: ReadArgs):
+        """Reads data from a specified source using the provided arguments.
+
+        :param args (ReadArgs): An object containing the parameters required for the read operation.
+
+        :return file: The result of the read operation, as returned by the client object.
+        """
+        return await self.client_obj.read(args)
+
+    async def write(self, args: WriteArgs):
+        return await self.client_obj.write(args)

saviialib-0.8.0/src/saviialib/libs/files_client/files_client_contract.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+
+from .types.files_client_types import ReadArgs, WriteArgs
+
+
+class FilesClientContract(ABC):
+    @abstractmethod
+    async def read(self, args: ReadArgs) -> str | bytes:
+        pass
+
+    @abstractmethod
+    async def write(self, arg: WriteArgs) -> None:
+        pass

saviialib-0.8.0/src/saviialib/libs/files_client/types/files_client_types.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+from typing import Literal
+
+
+@dataclass
+class FilesClientInitArgs:
+    client_name: str = "aiofiles_client"
+
+
+@dataclass
+class ReadArgs:
+    """
+    Represents the arguments required to read a file.
+
+    Attributes:
+        file_path (str): The path to the file to be read.
+        mode (Literal['r', 'rb']): The mode in which the file should be opened.
+            - 'r': Open for reading (text mode).
+            - 'rb': Open for reading (binary mode).
+    """
+
+    file_path: str
+    mode: Literal["r", "rb"]
+    encoding: str = "utf-8"
+
+
+@dataclass
+class WriteArgs:
+    destination_path: str
+    file_name: str
+    file_content: str | bytes

{saviialib-0.6.2 → saviialib-0.8.0}/src/saviialib/libs/zero_dependency/utils/datetime_utils.py

@@ -13,13 +13,13 @@ def today(timezone: str = "America/Santiago") -> str:
     return datetime.now(tz=ZoneInfo(timezone))
 
 
-def datetime_to_str(date: datetime, date_format: str = "%Y-%m-%dT%H:%M%:S") -> str:
+def datetime_to_str(date: datetime, date_format: str = "%m/%d/%Y, %H:%M:%S") -> str:
     """
     Convert a datetime object to a string in the specified format.
 
     :param date: The datetime object to convert.
     :param date_format: The format to convert the datetime object to.
-        Defaults to "YYYYMMDD:HHMMSS".
+        Defaults to "%Y-%m-%dT%H:%M:%S".
     :return: A string in the specified format.
     """
     return date.strftime(date_format)

saviialib-0.8.0/src/saviialib/services/epii/api.py

@@ -0,0 +1,79 @@
+from typing import Any, Dict
+
+from .controllers.types.update_thies_data_types import UpdateThiesDataControllerInput
+from .controllers.types.upload_backup_to_sharepoint_types import (
+    UploadBackupToSharepointControllerInput,
+)
+from .controllers.update_thies_data import UpdateThiesDataController
+from .controllers.upload_backup_to_sharepoint import UploadBackupToSharepointController
+from saviialib.general_types.api.epii_api_types import (
+    EpiiUpdateThiesConfig,
+    EpiiSharepointBackupConfig,
+    EpiiAPIConfig,
+)
+
+
+class EpiiAPI:
+    """
+    EpiiAPI is a service class that provides methods to interact with Patagonia Center system.
+    """
+
+    def __init__(self, config: EpiiAPIConfig):
+        self.ftp_port = config.ftp_port
+        self.ftp_host = config.ftp_host
+        self.ftp_user = config.ftp_user
+        self.ftp_password = config.ftp_password
+        self.sharepoint_client_id = config.sharepoint_client_id
+        self.sharepoint_client_secret = config.sharepoint_client_secret
+        self.sharepoint_tenant_id = config.sharepoint_tenant_id
+        self.sharepoint_tenant_name = config.sharepoint_tenant_name
+        self.sharepoint_site_name = config.sharepoint_site_name
+
+    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.
+
+        Returns:
+            response (dict): A dictionary representation of the API response.
+        """
+        config = EpiiUpdateThiesConfig(
+            ftp_port=self.ftp_port,
+            ftp_host=self.ftp_host,
+            ftp_user=self.ftp_user,
+            ftp_password=self.ftp_password,
+            sharepoint_client_id=self.sharepoint_client_id,
+            sharepoint_client_secret=self.sharepoint_client_secret,
+            sharepoint_site_name=self.sharepoint_site_name,
+            sharepoint_tenant_id=self.sharepoint_tenant_id,
+            sharepoint_tenant_name=self.sharepoint_tenant_name,
+        )
+        controller = UpdateThiesDataController(UpdateThiesDataControllerInput(config))
+        response = await controller.execute()
+        return response.__dict__
+
+    async def upload_backup_to_sharepoint(
+        self, local_backup_source_path: str
+    ) -> Dict[str, Any]:
+        """Migrate a backup folder from Home assistant to Sharepoint directory.
+        Args:
+            local_backup_source_path (str): Local path to backup.
+        Returns:
+            response (dict): A dictionary containing the response from the upload operation.
+                This dictionary will typically include information about the success or
+                failure of the upload, as well as any relevant metadata.
+        """
+        config = EpiiSharepointBackupConfig(
+            sharepoint_client_id=self.sharepoint_client_id,
+            sharepoint_client_secret=self.sharepoint_client_secret,
+            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,
+        )
+
+        controller = UploadBackupToSharepointController(
+            UploadBackupToSharepointControllerInput(config)
+        )
+        response = await controller.execute()
+        return response.__dict__

{saviialib-0.6.2 → saviialib-0.8.0}/src/saviialib/services/epii/controllers/types/update_thies_data_types.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass, field
 from typing import Dict
-from saviialib.general_types.api.update_thies_data_types import (
+from saviialib.general_types.api.epii_api_types import (
     EpiiUpdateThiesConfig,
 )
 

saviialib-0.8.0/src/saviialib/services/epii/controllers/types/upload_backup_to_sharepoint_types.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass, field
+from typing import Dict
+
+from saviialib.general_types.api.epii_api_types import EpiiSharepointBackupConfig
+
+
+@dataclass
+class UploadBackupToSharepointControllerInput:
+    config: EpiiSharepointBackupConfig
+
+
+@dataclass
+class UploadBackupToSharepointControllerOutput:
+    message: str
+    status: int
+    metadata: Dict[str, str] = field(default_factory=dict)

{saviialib-0.6.2 → saviialib-0.8.0}/src/saviialib/services/epii/controllers/update_thies_data.py

@@ -1,6 +1,6 @@
 from http import HTTPStatus
 
-from saviialib.general_types.error_types.api.update_thies_data_error_types import (
+from saviialib.general_types.error_types.api.epii_api_error_types import (
     SharePointFetchingError,
     ThiesConnectionError,
     ThiesFetchingError,

saviialib-0.8.0/src/saviialib/services/epii/controllers/upload_backup_to_sharepoint.py

@@ -0,0 +1,85 @@
+from http import HTTPStatus
+from saviialib.general_types.api.epii_api_types import SharepointConfig
+
+from saviialib.general_types.error_types.api.epii_api_error_types import (
+    BackupUploadError,
+    BackupSourcePathError,
+    BackupEmptyError,
+)
+from saviialib.general_types.error_types.common.common_types import (
+    EmptyDataError,
+    SharepointClientError,
+)
+from saviialib.services.epii.controllers.types.upload_backup_to_sharepoint_types import (
+    UploadBackupToSharepointControllerInput,
+    UploadBackupToSharepointControllerOutput,
+)
+from saviialib.services.epii.use_cases.types.upload_backup_to_sharepoint_types import (
+    UploadBackupToSharepointUseCaseInput,
+)
+from saviialib.services.epii.use_cases.upload_backup_to_sharepoint import (
+    UploadBackupToSharepointUsecase,
+)
+
+
+class UploadBackupToSharepointController:
+    def __init__(self, input: UploadBackupToSharepointControllerInput):
+        self.use_case = UploadBackupToSharepointUsecase(
+            UploadBackupToSharepointUseCaseInput(
+                sharepoint_config=SharepointConfig(
+                    sharepoint_client_id=input.config.sharepoint_client_id,
+                    sharepoint_client_secret=input.config.sharepoint_client_secret,
+                    sharepoint_site_name=input.config.sharepoint_site_name,
+                    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,
+            )
+        )
+
+    async def execute(self) -> UploadBackupToSharepointControllerOutput:
+        try:
+            data = await self.use_case.execute()
+            return UploadBackupToSharepointControllerOutput(
+                message="Local backup was migrated successfully",
+                status=HTTPStatus.OK.value,
+                metadata={"data": data},
+            )
+        except EmptyDataError:
+            return UploadBackupToSharepointControllerOutput(
+                message="No files to upload", status=HTTPStatus.NO_CONTENT.value
+            )
+
+        except (AttributeError, NameError, ValueError) as error:
+            return UploadBackupToSharepointControllerOutput(
+                message="An unexpected error occurred during use case initialization.",
+                status=HTTPStatus.BAD_REQUEST.value,
+                metadata={"error": error.__str__()},
+            )
+
+        except SharepointClientError as error:
+            return UploadBackupToSharepointControllerOutput(
+                message="Sharepoint Client initialization fails.",
+                status=HTTPStatus.INTERNAL_SERVER_ERROR.value,
+                metadata={"error": error.__str__()},
+            )
+
+        except BackupUploadError as error:
+            return UploadBackupToSharepointControllerOutput(
+                message="An error occurred during local backup",
+                status=HTTPStatus.MULTI_STATUS.value,
+                metadata={"error": error.__str__()},
+            )
+
+        except BackupSourcePathError as error:
+            return UploadBackupToSharepointControllerOutput(
+                message="Invalid local backup source path provided.",
+                status=HTTPStatus.BAD_REQUEST.value,
+                metadata={"error": error.__str__()},
+            )
+        except BackupEmptyError as error:
+            return UploadBackupToSharepointControllerOutput(
+                message="Each folder in the backup folder is empty. Check out again",
+                status=HTTPStatus.EXPECTATION_FAILED.value,
+                metadata={"error": error.__str__()},
+            )

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

@@ -0,0 +1,5 @@
+SHAREPOINT_BASE_URL = "/sites/uc365_CentrosyEstacionesRegionalesUC/Shared%20Documents/General/Test_Raspberry"
+DESTINATION_FOLDERS = {
+    "CAM1": "Camaras_Trampa",
+    "RECORDS1": "Grabaciones",
+}

{saviialib-0.6.2 → saviialib-0.8.0}/src/saviialib/services/epii/use_cases/types/update_thies_data_types.py

@@ -1,22 +1,6 @@
 from dataclasses import dataclass, field
 from typing import Dict
-
-
-@dataclass
-class FtpClientConfig:
-    ftp_host: str
-    ftp_port: int
-    ftp_user: str
-    ftp_password: str
-
-
-@dataclass
-class SharepointConfig:
-    sharepoint_client_id: str
-    sharepoint_client_secret: str
-    sharepoint_tenant_id: str
-    sharepoint_tenant_name: str
-    sharepoint_site_name: str
+from saviialib.general_types.api.epii_api_types import FtpClientConfig, SharepointConfig
 
 
 @dataclass

saviialib-0.8.0/src/saviialib/services/epii/use_cases/types/upload_backup_to_sharepoint_types.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+from saviialib.general_types.api.epii_api_types import SharepointConfig
+
+
+@dataclass
+class UploadBackupToSharepointUseCaseInput:
+    sharepoint_config: SharepointConfig
+    local_backup_source_path: str

{saviialib-0.6.2 → saviialib-0.8.0}/src/saviialib/services/epii/use_cases/update_thies_data.py

@@ -1,7 +1,5 @@
-from dotenv import load_dotenv
-
-import saviialib.services.epii.constants.update_thies_data_constants as c
-from saviialib.general_types.error_types.api.update_thies_data_error_types import (
+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,
     SharePointUploadError,
     ThiesConnectionError,
@@ -33,8 +31,6 @@ from saviialib.services.epii.utils import (
     parse_execute_response,
 )
 
-load_dotenv()
-
 
 class UpdateThiesDataUseCase:
     def __init__(self, input: UpdateThiesDataUseCaseInput):
@@ -122,7 +118,7 @@ class UpdateThiesDataUseCase:
         self, files: dict
     ) -> dict[str, list[str]]:
         """Upload files to SharePoint and categorize the results."""
-        upload_results = {"failed_files": [], "overwritten_files": [], "new_files": []}
+        upload_results = {"failed_files": [], "new_files": []}
 
         async with self.sharepoint_client:
             for file, file_content in files.items():
@@ -133,12 +129,8 @@ class UpdateThiesDataUseCase:
                         file_content=file_content,
                         file_name=file_name,
                     )
-                    response = await self.sharepoint_client.upload_file(args)
-
-                    if response.get("Exists", False):
-                        upload_results["overwritten_files"].append(file)
-                    else:
-                        upload_results["new_files"].append(file)
+                    await self.sharepoint_client.upload_file(args)
+                    upload_results["new_files"].append(file)
 
                 except ConnectionError as error:
                     upload_results["failed_files"].append(

saviialib-0.8.0/src/saviialib/services/epii/use_cases/upload_backup_to_sharepoint.py

@@ -0,0 +1,201 @@
+import asyncio
+import os
+from time import time
+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,
+    BackupUploadError,
+)
+from saviialib.general_types.error_types.common import (
+    SharepointClientError,
+)
+from saviialib.libs.files_client import FilesClient, FilesClientInitArgs, ReadArgs
+from saviialib.libs.sharepoint_client import (
+    SharepointClient,
+    SharepointClientInitArgs,
+    SpUploadFileArgs,
+)
+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,
+)
+
+from .types.upload_backup_to_sharepoint_types import (
+    UploadBackupToSharepointUseCaseInput,
+)
+
+
+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.files_client = self._initialize_files_client()
+        self.total_files = sum(
+            len(files) for files in self.grouped_files_by_folder.values()
+        )
+        self.log_history = []
+
+    def _initialize_files_client(self):
+        return FilesClient(FilesClientInitArgs(client_name="aiofiles_client"))
+
+    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):
+            return {}
+        return {
+            folder_name: [
+                file_name
+                for file_name in os.listdir(
+                    os.path.join(self.local_backup_source_path, folder_name)
+                )
+            ]
+            for folder_name in os.listdir(self.local_backup_source_path)
+        }
+
+    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 export_file_to_sharepoint(
+        self, folder_name: str, file_name: str, file_content: bytes
+    ) -> tuple[bool, str]:
+        """Uploads a file to the specified folder in SharePoint."""
+        uploaded = None
+        error_message = ""
+
+        try:
+            sharepoint_client = SharepointClient(
+                SharepointClientInitArgs(
+                    self.sharepoint_config, client_name="sharepoint_rest_api"
+                )
+            )
+        except ConnectionError as error:
+            raise SharepointClientError(error)
+
+        async with sharepoint_client:
+            try:
+                destination_folder = c.DESTINATION_FOLDERS.get(folder_name, folder_name)
+                folder_url = f"{c.SHAREPOINT_BASE_URL}/{destination_folder}"
+                args = SpUploadFileArgs(
+                    folder_relative_url=folder_url,
+                    file_content=file_content,
+                    file_name=file_name,
+                )
+                await sharepoint_client.upload_file(args)
+                uploaded = True
+            except ConnectionError as error:
+                error_message = str(error)
+                uploaded = False
+
+        return uploaded, error_message
+
+    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)
+        print(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)
+        self.log_history.append(result_message)
+        return {
+            "parent_folder": folder_name,
+            "file_name": file_name,
+            "uploaded": uploaded,
+            "error_message": error_message,
+        }
+
+    async def retry_upload_failed_files(self, results) -> None:
+        failed_files = [item for item in results if not item["uploaded"]]
+        tasks = []
+        retry_message = (
+            f"[BACKUP] Retrying upload for {len(failed_files)} failed files... 🚨"
+        )
+        self.log_history.append(retry_message)
+        print(retry_message)
+        for file in failed_files:
+            tasks.append(
+                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))
+        else:
+            successful_upload_retry = (
+                "[BACKUP] All files uploaded successfully after retry."
+            )
+            self.log_history.append(successful_upload_retry)
+            print(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."""
+        tasks = []
+        start_time = time()
+        if not directory_exists(self.local_backup_source_path):
+            raise BackupSourcePathError(
+                reason=f"'{self.local_backup_source_path}' doesn't exist."
+            )
+        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)
+            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)
+                == 0
+            ):
+                empty_folder_message = f"[BACKUP] The folder '{folder_name}' is empty ⚠️"
+                print(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)
+            for file_name in self.grouped_files_by_folder[folder_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)
+        success = calculate_percentage_uploaded(results, self.total_files)
+        if success < 100.0:
+            await self.retry_upload_failed_files(results)
+        else:
+            end_time = time()
+            backup_time = end_time - start_time
+            successful_backup_message = (
+                f"[BACKUP] Migration time: {backup_time:.2f} seconds ✨"
+            )
+            self.log_history.append(successful_backup_message)
+
+            finished_backup_message = (
+                "[BACKUP] All the files were uploaded successfully 🎉"
+            )
+            self.log_history.append(finished_backup_message)
+
+            self._save_log_history()
+            return parse_execute_response(results)

saviialib-0.8.0/src/saviialib/services/epii/utils/upload_backup_to_sharepoint_utils.py

@@ -0,0 +1,92 @@
+import re
+from typing import List, Dict, Optional
+import os
+
+
+def extract_error_information(error: str) -> Optional[Dict[str, str]]:
+    match = re.search(r"(\d+), message='([^']*)', url=\"([^\"]*)\"", error)
+    if match:
+        return {
+            "status_code": match.group(1),
+            "message": match.group(2),
+            "url": match.group(3),
+        }
+    return None
+
+
+def explain_status_code(status_code: int) -> str:
+    explanations = {
+        404: "Probably an error with file or folder source path.",
+        403: "Permission denied when accessing the source path.",
+        500: "Internal server error occurred during upload.",
+    }
+    return explanations.get(status_code, "Unknown error occurred.")
+
+
+def extract_error_message(results: List[Dict], success: float) -> str:
+    print(
+        "[BACKUP] Not all files uploaded ⚠️\n"
+        f"[BACKUP] Files failed to upload: {(1 - success):.2%}"
+    )
+
+    failed_files = [item for item in results if not item.get("uploaded")]
+
+    error_data = []
+    for item in failed_files:
+        error_info = extract_error_information(item.get("error_message", ""))
+        if error_info:
+            error_data.append(
+                {
+                    "file_name": item["file_name"],
+                    "status_code": error_info["status_code"],
+                    "message": error_info["message"],
+                    "url": error_info["url"],
+                }
+            )
+
+    # Group errors by code.
+    grouped_errors: Dict[str, List[Dict]] = {}
+    for error in error_data:
+        code = error["status_code"]
+        grouped_errors.setdefault(code, []).append(error)
+
+    # Summary
+    for code, items in grouped_errors.items():
+        print(f"[BACKUP] Status code {code} - {explain_status_code(int(code))}")
+        for item in items:
+            print(
+                f"[BACKUP] File {item['file_name']}, url: {item['url']}, message: {item['message']}"
+            )
+
+    failed_file_names = [item["file_name"] for item in failed_files]
+    return f"Failed files: {', '.join(failed_file_names)}."
+
+
+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")]
+        ),
+    }
+
+
+def show_upload_result(uploaded: bool, file_name: str) -> str:
+    status = "✅" if uploaded else "❌"
+    message = "was uploaded successfully" if uploaded else "failed to upload"
+    result = f"[BACKUP] File {file_name} {message} {status}"
+    return result
+
+
+def calculate_percentage_uploaded(results: List[Dict], total_files: int) -> float:
+    uploaded_count = sum(
+        1 for result in results if isinstance(result, dict) and result.get("uploaded")
+    )
+    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)))

saviialib-0.6.2/src/saviialib/general_types/api/__init__.py

@@ -1,3 +0,0 @@
-from .update_thies_data_types import EpiiUpdateThiesConfig
-
-__all__ = ["EpiiUpdateThiesConfig"]

saviialib-0.6.2/src/saviialib/general_types/api/update_thies_data_types.py

@@ -1,30 +0,0 @@
-from dataclasses import dataclass
-
-
-@dataclass
-class EpiiUpdateThiesConfig:
-    """
-    Configuration for Epii API.
-
-    Attributes:
-        ftp_port (int): Port number of the FTP server.
-        ftp_host (str): Hostname or IP address of the FTP server.
-        ftp_user (str): Username for the FTP server.
-        ftp_password (str): Password for the FTP server.
-        sharepoint_client_id (str): Client ID for SharePoint authentication.
-        sharepoint_client_secret (str): Client secret for SharePoint authentication.
-        sharepoint_tenant_id (str): Tenant ID for SharePoint authentication.
-        sharepoint_tenant_name (str): Tenant name for SharePoint.
-        sharepoint_site_name (str): Site name in SharePoint.
-        logger (Logger): Logger object for logging during synchronisation of files from THIES Data Logger
-    """
-
-    ftp_port: int
-    ftp_host: str
-    ftp_user: str
-    ftp_password: str
-    sharepoint_client_id: str
-    sharepoint_client_secret: str
-    sharepoint_tenant_id: str
-    sharepoint_tenant_name: str
-    sharepoint_site_name: str

saviialib-0.6.2/src/saviialib/services/epii/api.py

@@ -1,26 +0,0 @@
-from typing import Any, Dict
-
-from .controllers.types.update_thies_data_types import UpdateThiesDataControllerInput
-from .controllers.update_thies_data import UpdateThiesDataController
-from saviialib.general_types.api.update_thies_data_types import (
-    EpiiUpdateThiesConfig,
-)
-
-
-class EpiiAPI:
-    """
-    EpiiAPI is a service class that provides methods to interact with Patagonia Center system.
-    """
-
-    async def update_thies_data(self, config: EpiiUpdateThiesConfig) -> Dict[str, Any]:
-        """
-        This method establishes a connection to an FTP server using the provided
-        credentials and updates data related to THIES Data Logger.
-        Args:
-            config (EpiiUpdateThiesConfig): configuration class for FTP Server and Microsoft SharePoint credentials.
-        Returns:
-            response (dict): A dictionary representation of the API response.
-        """
-        controller = UpdateThiesDataController(UpdateThiesDataControllerInput(config))
-        response = await controller.execute()
-        return response.__dict__

saviialib-0.6.2/src/saviialib/services/epii/controllers/__init__.py

@@ -1,3 +0,0 @@
-from .update_thies_data import UpdateThiesDataController
-
-__all__ = ["UpdateThiesDataController"]