saviialib 0.6.1__py3-none-any.whl

saviialib/__init__.py

@@ -0,0 +1,9 @@
+# read version from installed package
+from importlib.metadata import version
+
+__version__ = version("saviialib")
+
+from .services.epii.api import EpiiAPI
+from .general_types.api.update_thies_data_types import EpiiUpdateThiesConfig
+
+__all__ = ["EpiiAPI", "EpiiUpdateThiesConfig"]

saviialib/general_types/api/__init__.py

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

saviialib/general_types/api/update_thies_data_types.py

@@ -0,0 +1,30 @@
+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/general_types/error_types/api/update_thies_data_error_types.py

@@ -0,0 +1,57 @@
+import json
+
+
+class ThiesConnectionError(Exception):
+    """Raised when unable to connect to the THIES FTP Server"""
+
+    def __init__(self, *args, reason):
+        super().__init__(*args, reason)
+        self.reason = reason
+
+    def __str__(self):
+        return "Unable to connect to THIES FTP Server. " + self.reason.__str__()
+
+
+class ThiesFetchingError(Exception):
+    """Raised when no files are found to upload to the server."""
+
+    def __init__(self, *args, reason):
+        super().__init__(*args, reason)
+        self.reason = reason
+
+    def __str__(self):
+        return (
+            "An error ocurred while retrieving files from THIES FTP Server. "
+            + self.reason.__str__()
+        )
+
+
+class SharePointFetchingError(Exception):
+    """Raised when there is an error fetching file names from the RCER cloud."""
+
+    def __init__(self, *args, reason):
+        super().__init__(*args, reason)
+        self.reason = reason
+
+    def __str__(self):
+        try:
+            _, internal_metadata = self.reason.__str__().split(",", 1)
+            internal_metadata_dict = json.loads(internal_metadata)
+            return internal_metadata_dict["error_description"]
+
+        except json.decoder.JSONDecodeError:
+            return self.reason.__str__()
+
+
+class SharePointUploadError(Exception):
+    """Raised when there is an error uploading files to the Microsoft SharePoint folder."""
+
+    def __init__(self, *args, reason):
+        super().__init__(*args, reason)
+        self.reason = reason
+
+    def __str__(self):
+        return (
+            "An error occurred while uploading files to the Microsoft SharePoint folder. "
+            + self.reason.__str__()
+        )

saviialib/general_types/error_types/common/__init__.py

@@ -0,0 +1,7 @@
+from .common_types import (
+    EmptyDataError,
+    FtpClientError,
+    SharepointClientError,
+)
+
+__all__ = ["EmptyDataError", "SharepointClientError", "FtpClientError"]

saviialib/general_types/error_types/common/common_types.py

@@ -0,0 +1,17 @@
+class EmptyDataError(Exception):
+    def __init__(self, *args, reason):
+        super().__init__(*args, reason)
+        self.reason = reason
+
+    def __str__(self):
+        return "The data provided is empty. " + self.reason.__str__()
+
+
+class SharepointClientError(Exception):
+    def __str__(self):
+        return "SharePoint API REST Client initialization fails."
+
+
+class FtpClientError(Exception):
+    def __str__(self):
+        return "Ftp Client initialization fails."

saviialib/libs/ftp_client/__init__.py

@@ -0,0 +1,4 @@
+from .ftp_client import FTPClient
+from .types import FtpClientInitArgs, FtpListFilesArgs, FtpReadFileArgs
+
+__all__ = ["FTPClient", "FtpClientInitArgs", "FtpListFilesArgs", "FtpReadFileArgs"]

saviialib/libs/ftp_client/clients/aioftp_client.py

@@ -0,0 +1,45 @@
+from aioftp import Client
+from aioftp.errors import StatusCodeError
+from saviialib.libs.ftp_client.ftp_client_contract import (
+    FTPClientContract,
+)
+from saviialib.libs.ftp_client.types.ftp_client_types import (
+    FtpClientInitArgs,
+    FtpListFilesArgs,
+    FtpReadFileArgs,
+)
+
+
+class AioFTPClient(FTPClientContract):
+    def __init__(self, args: FtpClientInitArgs) -> None:
+        self.host = args.config.ftp_host
+        self.port = args.config.ftp_port
+        self.password = args.config.ftp_password
+        self.user = args.config.ftp_user
+        self.client = Client()
+
+    async def _async_start(self) -> None:
+        try:
+            await self.client.connect(host=self.host, port=self.port)
+        except OSError:
+            raise ConnectionRefusedError(
+                f"{self.host}:{self.port} isn't active. "
+                "Please ensure the server is running and accessible."
+            )
+        try:
+            await self.client.login(user=self.user, password=self.password)
+        except StatusCodeError:
+            raise ConnectionAbortedError(
+                "Authentication failed. Please verify your credentials and try again."
+            )
+
+    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)
+        ]
+
+    async def read_file(self, args: FtpReadFileArgs) -> bytes:
+        await self._async_start()
+        async with self.client.download_stream(args.file_path) as stream:
+            return await stream.read()

saviialib/libs/ftp_client/ftp_client.py

@@ -0,0 +1,22 @@
+from .clients.aioftp_client import AioFTPClient
+from .ftp_client_contract import FTPClientContract
+from .types.ftp_client_types import FtpClientInitArgs, FtpListFilesArgs, FtpReadFileArgs
+
+
+class FTPClient(FTPClientContract):
+    CLIENTS = {"aioftp_client"}
+
+    def __init__(self, args: FtpClientInitArgs) -> None:
+        if args.client_name not in FTPClient.CLIENTS:
+            msg = f"Unsupported client {args.client_name}"
+            raise KeyError(msg)
+
+        if args.client_name == "aioftp_client":
+            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)
+
+    def read_file(self, args: FtpReadFileArgs) -> bytes:
+        return self.client_obj.read_file(args)

saviialib/libs/ftp_client/ftp_client_contract.py

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

saviialib/libs/ftp_client/types/__init__.py

@@ -0,0 +1,3 @@
+from .ftp_client_types import FtpClientInitArgs, FtpListFilesArgs, FtpReadFileArgs
+
+__all__ = ["FtpClientInitArgs", "FtpListFilesArgs", "FtpReadFileArgs"]

saviialib/libs/ftp_client/types/ftp_client_types.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class FtpClientInitArgs:
+    config: Any
+    client_name: str = "aioftp_client"
+
+
+@dataclass
+class FtpListFilesArgs:
+    path: str
+
+
+@dataclass
+class FtpReadFileArgs:
+    file_path: str

saviialib/libs/sharepoint_client/__init__.py

@@ -0,0 +1,15 @@
+from .sharepoint_client import SharepointClient
+from .types.sharepoint_client_types import (
+    SharepointClientInitArgs,
+    SpListFilesArgs,
+    SpListFoldersArgs,
+    SpUploadFileArgs,
+)
+
+__all__ = [
+    "SharepointClientInitArgs",
+    "SharepointClient",
+    "SpListFilesArgs",
+    "SpListFoldersArgs",
+    "SpUploadFileArgs",
+]

saviialib/libs/sharepoint_client/clients/sharepoint_rest_api.py

@@ -0,0 +1,135 @@
+from typing import Any
+
+from aiohttp import ClientError, ClientSession
+from dotenv import load_dotenv
+
+from saviialib.libs.sharepoint_client.sharepoint_client_contract import (
+    SharepointClientContract,
+)
+from saviialib.libs.sharepoint_client.types.sharepoint_client_types import (
+    SpListFilesArgs,
+    SpListFoldersArgs,
+    SpUploadFileArgs,
+    SharepointClientInitArgs,
+)
+
+load_dotenv()
+
+
+class SharepointRestAPI(SharepointClientContract):
+    def __init__(self, args: SharepointClientInitArgs):
+        self.session: ClientSession | None = None
+        self.base_headers = {}
+        self.credentials = {}
+        self.base_url = ""
+        self.tenant_id = args.config.sharepoint_tenant_id
+        self.tenant_name = args.config.sharepoint_tenant_name
+        self.client_secret = args.config.sharepoint_client_secret
+        self.client_id = args.config.sharepoint_client_id
+        self.site_name = args.config.sharepoint_site_name
+
+    async def _load_form_digest_value(self) -> str:
+        try:
+            response = await self.session.post("contextinfo")
+            response_json = await response.json()
+            return response_json["FormDigestValue"]
+        except ClientError as error:
+            raise ConnectionError(error) from error
+
+    async def _load_credentials(self) -> dict:
+        resource_base = "00000003-0000-0ff1-ce00-000000000000"
+        resource = f"{resource_base}/{self.tenant_name}.sharepoint.com@{self.tenant_id}"
+        url = f"https://accounts.accesscontrol.windows.net/{self.tenant_id}/tokens/OAuth/2"
+        payload = {
+            "grant_type": "client_credentials",
+            "client_id": f"{self.client_id}@{self.tenant_id}",
+            "client_secret": self.client_secret,
+            "resource": resource,
+        }
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded",
+        }
+
+        async with ClientSession() as session:
+            # Load access token
+            response = await session.post(url, data=payload, headers=headers)
+            if response.status != 200:
+                raise ClientError(
+                    f"Failed to fetch credentials: {response.status}, {await response.text()}"
+                )
+            response_json = await response.json()
+
+            return {
+                "access_token": response_json["access_token"],
+            }
+
+    async def __aenter__(self) -> "SharepointRestAPI":
+        try:
+            self.credentials = await self._load_credentials()
+            site_url = f"https://{self.tenant_name}.sharepoint.com"
+
+            self.base_headers = {
+                "Authorization": f"Bearer {self.credentials['access_token']}",
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+            }
+            self.base_url = f"{site_url}/sites/{self.site_name}/_api/"
+            self.session = ClientSession(
+                headers=self.base_headers, base_url=self.base_url
+            )
+            return self
+        except ClientError as error:
+            raise ConnectionError(error)
+
+    async def __aexit__(
+        self, _exc_type: type[BaseException], _exc_val: BaseException, _exc_tb: Any
+    ) -> None:
+        await self.session.close()
+
+    async def list_files(self, args: SpListFilesArgs) -> list:
+        try:
+            folder_relative_url = (
+                f"GetFolderByServerRelativeUrl('{args.folder_relative_url}')"
+            )
+            endpoint = f"web/{folder_relative_url}/Files"
+            response = await self.session.get(endpoint.lstrip("/"))
+            response.raise_for_status()
+            response_json = await response.json()
+            return response_json
+        except ClientError as error:
+            raise ConnectionError(error) from error
+
+    async def list_folders(self, args: SpListFoldersArgs) -> list:
+        try:
+            folder_relative_url = (
+                f"GetFolderByServerRelativeUrl('{args.folder_relative_url}')"
+            )
+            endpoint = f"web/{folder_relative_url}/Folder"
+            response = await self.session.get(endpoint.lstrip("/"))
+            response.raise_for_status()
+            return await response.json()
+        except ClientError as error:
+            raise ConnectionError(error) from error
+
+    async def upload_file(self, args: SpUploadFileArgs) -> dict:
+        try:
+            # Load form digest value
+            form_digest_value = await self._load_form_digest_value()
+            headers = {
+                **self.base_headers,
+                "X-RequestDigest": form_digest_value,
+                "Content-Type": "application/octet-stream",
+            }
+            # Upload the file in the requested folder
+            folder_relative_url = (
+                f"GetFolderByServerRelativeUrl('{args.folder_relative_url}')"
+            )
+            data = args.file_content
+
+            endpoint = f"web/{folder_relative_url}/Files/add(url='{args.file_name}',overwrite=true)"
+            response = await self.session.post(endpoint, data=data, headers=headers)
+
+            response.raise_for_status()
+            return await response.json()
+        except ClientError as error:
+            raise ConnectionError(error) from error

saviialib/libs/sharepoint_client/sharepoint_client.py

@@ -0,0 +1,34 @@
+from .clients.sharepoint_rest_api import SharepointRestAPI
+from .sharepoint_client_contract import SharepointClientContract
+from .types.sharepoint_client_types import (
+    SharepointClientInitArgs,
+    SpListFilesArgs,
+    SpListFoldersArgs,
+    SpUploadFileArgs,
+)
+
+
+class SharepointClient(SharepointClientContract):
+    CLIENTS = {"sharepoint_rest_api"}
+
+    def __init__(self, args: SharepointClientInitArgs):
+        if args.client_name not in SharepointClient.CLIENTS:
+            msg = f"Unsupported client {args.client_name}"
+            raise KeyError(msg)
+        elif args.client_name == "sharepoint_rest_api":
+            self.client_obj = SharepointRestAPI(args)
+
+    async def __aenter__(self):
+        return await self.client_obj.__aenter__()
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.client_obj.__aexit__(exc_type, exc_val, exc_tb)
+
+    async def list_files(self, args: SpListFilesArgs) -> list:
+        return await self.client_obj.list_files(args)
+
+    async def list_folders(self, args: SpListFoldersArgs) -> list:
+        return await self.client_obj.list_files(args)
+
+    async def upload_file(self, args: SpUploadFileArgs) -> dict:
+        return await self.client_obj.upload_file(args)

saviialib/libs/sharepoint_client/sharepoint_client_contract.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+
+from .types.sharepoint_client_types import (
+    SpListFilesArgs,
+    SpListFoldersArgs,
+    SpUploadFileArgs,
+)
+
+
+class SharepointClientContract(ABC):
+    @abstractmethod
+    async def list_files(self, args: SpListFilesArgs) -> list:
+        pass
+
+    @abstractmethod
+    async def list_folders(self, args: SpListFoldersArgs) -> list:
+        pass
+
+    @abstractmethod
+    async def upload_file(self, args: SpUploadFileArgs) -> dict:
+        pass

saviialib/libs/sharepoint_client/types/sharepoint_client_types.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class SharepointClientInitArgs:
+    config: Any
+    client_name: str = "sharepoint_rest_api"
+
+
+@dataclass
+class SpListFilesArgs:
+    folder_relative_url: str
+
+
+@dataclass
+class SpListFoldersArgs:
+    folder_relative_url: str
+
+
+@dataclass
+class SpUploadFileArgs:
+    folder_relative_url: str
+    file_name: str
+    file_content: bytes = bytes()

saviialib/libs/zero_dependency/utils/datetime_utils.py

@@ -0,0 +1,25 @@
+from datetime import datetime
+from zoneinfo import ZoneInfo
+
+
+def today(timezone: str = "America/Santiago") -> str:
+    """
+    Return the current date.
+
+    :param timezone: A string representing the IANA timezone name.
+        Defaults to "America/Santiago".
+    :return datetime:
+    """
+    return datetime.now(tz=ZoneInfo(timezone))
+
+
+def datetime_to_str(date: datetime, date_format: str = "%Y-%m-%dT%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".
+    :return: A string in the specified format.
+    """
+    return date.strftime(date_format)

saviialib/services/epii/api.py

@@ -0,0 +1,26 @@
+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/services/epii/constants/update_thies_data_constants.py

@@ -0,0 +1,5 @@
+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/services/epii/controllers/__init__.py

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

saviialib/services/epii/controllers/types/__init__.py

@@ -0,0 +1,6 @@
+from .update_thies_data_types import (
+    UpdateThiesDataControllerInput,
+    UpdateThiesDataControllerOutput,
+)
+
+__all__ = ["UpdateThiesDataControllerInput", "UpdateThiesDataControllerOutput"]

saviialib/services/epii/controllers/types/update_thies_data_types.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass, field
+from typing import Dict
+from saviialib.general_types.api.update_thies_data_types import (
+    EpiiUpdateThiesConfig,
+)
+
+
+@dataclass
+class UpdateThiesDataControllerInput:
+    config: EpiiUpdateThiesConfig
+
+
+@dataclass
+class UpdateThiesDataControllerOutput:
+    message: str
+    status: int
+    metadata: Dict[str, str] = field(default_factory=dict)

saviialib/services/epii/controllers/update_thies_data.py

@@ -0,0 +1,107 @@
+from http import HTTPStatus
+
+from saviialib.general_types.error_types.api.update_thies_data_error_types import (
+    SharePointFetchingError,
+    ThiesConnectionError,
+    ThiesFetchingError,
+    SharePointUploadError,
+)
+from saviialib.general_types.error_types.common.common_types import (
+    EmptyDataError,
+    FtpClientError,
+    SharepointClientError,
+)
+from saviialib.services.epii.controllers.types.update_thies_data_types import (
+    UpdateThiesDataControllerInput,
+    UpdateThiesDataControllerOutput,
+)
+from saviialib.services.epii.use_cases.types import (
+    UpdateThiesDataUseCaseInput,
+    SharepointConfig,
+    FtpClientConfig,
+)
+from saviialib.services.epii.use_cases.update_thies_data import (
+    UpdateThiesDataUseCase,
+)
+
+
+class UpdateThiesDataController:
+    def __init__(self, input: UpdateThiesDataControllerInput):
+        self.use_case = UpdateThiesDataUseCase(
+            UpdateThiesDataUseCaseInput(
+                ftp_config=FtpClientConfig(
+                    ftp_host=input.config.ftp_host,
+                    ftp_password=input.config.ftp_password,
+                    ftp_port=input.config.ftp_port,
+                    ftp_user=input.config.ftp_user,
+                ),
+                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,
+                ),
+            )
+        )
+
+    async def execute(self) -> UpdateThiesDataControllerOutput:
+        try:
+            data = await self.use_case.execute()
+            return UpdateThiesDataControllerOutput(
+                message="THIES was synced successfully",
+                status=HTTPStatus.OK.value,
+                metadata={"data": data},
+            )
+        except EmptyDataError:
+            return UpdateThiesDataControllerOutput(
+                message="No files to upload", status=HTTPStatus.NO_CONTENT.value
+            )
+
+        except (AttributeError, NameError, ValueError) as error:
+            return UpdateThiesDataControllerOutput(
+                message="An unexpected error occurred during use case initialization.",
+                status=HTTPStatus.BAD_REQUEST.value,
+                metadata={"error": error.__str__()},
+            )
+        except FtpClientError as error:
+            return UpdateThiesDataControllerOutput(
+                message="Ftp Client initialization fails.",
+                status=HTTPStatus.BAD_REQUEST.value,
+                metadata={"error": error.__str__()},
+            )
+
+        except SharepointClientError as error:
+            return UpdateThiesDataControllerOutput(
+                message="Sharepoint Client initialization fails.",
+                status=HTTPStatus.INTERNAL_SERVER_ERROR.value,
+                metadata={"error": error.__str__()},
+            )
+
+        except SharePointFetchingError as error:
+            return UpdateThiesDataControllerOutput(
+                message="An error occurred while retrieving file names from Microsoft SharePoint",
+                status=HTTPStatus.BAD_REQUEST.value,
+                metadata={"error": error.__str__()},
+            )
+
+        except SharePointUploadError as error:
+            return UpdateThiesDataControllerOutput(
+                message="An error oucrred while uploading files to RCER Cloud",
+                status=HTTPStatus.BAD_REQUEST.value,
+                metadata={"error": error.__str__()},
+            )
+
+        except ThiesFetchingError as error:
+            return UpdateThiesDataControllerOutput(
+                message="An error ocurred while retrieving file names from THIES FTP Server.",
+                status=HTTPStatus.NO_CONTENT.value,
+                metadata={"error": error.__str__()},
+            )
+
+        except ThiesConnectionError as error:
+            return UpdateThiesDataControllerOutput(
+                message="Unable to connect to THIES Data Logger FTP Server.",
+                status=HTTPStatus.INTERNAL_SERVER_ERROR.value,
+                metadata={"error": error.__str__()},
+            )

saviialib/services/epii/use_cases/types/__init__.py

@@ -0,0 +1,7 @@
+from .update_thies_data_types import (
+    FtpClientConfig,
+    SharepointConfig,
+    UpdateThiesDataUseCaseInput,
+)
+
+__all__ = ["UpdateThiesDataUseCaseInput", "FtpClientConfig", "SharepointConfig"]

saviialib/services/epii/use_cases/types/update_thies_data_types.py

@@ -0,0 +1,32 @@
+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
+
+
+@dataclass
+class UpdateThiesDataUseCaseInput:
+    ftp_config: FtpClientConfig
+    sharepoint_config: SharepointConfig
+
+
+@dataclass
+class UpdateThiesDataUseCaseOutput:
+    message: str
+    status: int = 0
+    metadata: Dict[str, str] = field(default_factory=dict)

saviialib/services/epii/use_cases/update_thies_data.py

@@ -0,0 +1,179 @@
+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 (
+    SharePointFetchingError,
+    SharePointUploadError,
+    ThiesConnectionError,
+    ThiesFetchingError,
+)
+from saviialib.general_types.error_types.common import (
+    EmptyDataError,
+    FtpClientError,
+    SharepointClientError,
+)
+from saviialib.libs.ftp_client import (
+    FTPClient,
+    FtpClientInitArgs,
+    FtpListFilesArgs,
+    FtpReadFileArgs,
+)
+from saviialib.libs.sharepoint_client import (
+    SharepointClient,
+    SharepointClientInitArgs,
+    SpListFilesArgs,
+    SpUploadFileArgs,
+)
+from saviialib.services.epii.use_cases.types import (
+    FtpClientConfig,
+    SharepointConfig,
+    UpdateThiesDataUseCaseInput,
+)
+from saviialib.services.epii.utils import (
+    parse_execute_response,
+)
+
+load_dotenv()
+
+
+class UpdateThiesDataUseCase:
+    def __init__(self, input: UpdateThiesDataUseCaseInput):
+        self.sharepoint_client = self._initialize_sharepoint_client(
+            input.sharepoint_config
+        )
+        self.thies_ftp_client = self._initialize_thies_ftp_client(input.ftp_config)
+        self.uploading = set()
+
+    def _initialize_sharepoint_client(
+        self, config: SharepointConfig
+    ) -> SharepointClient:
+        """Initialize the HTTP client."""
+        try:
+            return SharepointClient(
+                SharepointClientInitArgs(config, client_name="sharepoint_rest_api")
+            )
+        except ConnectionError as error:
+            raise SharepointClientError(error)
+
+    def _initialize_thies_ftp_client(self, config: FtpClientConfig) -> FTPClient:
+        """Initialize the FTP client."""
+        try:
+            return FTPClient(FtpClientInitArgs(config, client_name="aioftp_client"))
+        except RuntimeError as error:
+            raise FtpClientError(error)
+
+    async def fetch_cloud_file_names(self) -> set[str]:
+        """Fetch file names from the RCER cloud."""
+
+        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}"
+                    )
+                    response = await self.sharepoint_client.list_files(args)
+                    cloud_files.update(
+                        {f"{folder}_{item['Name']}" for item in response["value"]}
+                    )
+            return cloud_files
+        except ConnectionError 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
+            }
+        except ConnectionRefusedError as error:
+            raise ThiesConnectionError(reason=error)
+        except ConnectionAbortedError as error:
+            raise ThiesFetchingError(reason=error)
+
+    async def fetch_thies_file_content(self) -> dict[str, bytes]:
+        """Fetch the content of files from the THIES FTP server."""
+        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}"
+                )
+                content = await self.thies_ftp_client.read_file(
+                    FtpReadFileArgs(file_path)
+                )
+                content_files[file] = content  # Save the file with its prefix
+            return content_files
+        except ConnectionRefusedError as error:
+            raise ThiesConnectionError(reason=error)
+        except ConnectionAbortedError as error:
+            raise ThiesFetchingError(reason=error)
+
+    async def upload_thies_files_to_sharepoint(
+        self, files: dict
+    ) -> dict[str, list[str]]:
+        """Upload files to SharePoint and categorize the results."""
+        upload_results = {"failed_files": [], "overwritten_files": [], "new_files": []}
+
+        async with self.sharepoint_client:
+            for file, file_content in files.items():
+                try:
+                    folder, file_name = file.split("_", 1)
+                    args = SpUploadFileArgs(
+                        folder_relative_url=f"{c.SHAREPOINT_BASE_URL}/{folder}",
+                        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)
+
+                except ConnectionError as error:
+                    upload_results["failed_files"].append(
+                        f"{file} (Error: {str(error)})"
+                    )
+
+        if upload_results["failed_files"]:
+            raise SharePointUploadError(
+                reason="Files failed to upload: "
+                + ", ".join(upload_results["failed_files"])
+            )
+
+        return upload_results
+
+    async def execute(self) -> dict:
+        """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)
+
+        self.uploading = thies_files - cloud_files
+        if not self.uploading:
+            raise EmptyDataError(reason="No files to upload.")
+
+        # Fetch the content of the files to be uploaded from THIES FTP Server
+        thies_fetched_files = await self.fetch_thies_file_content()
+
+        # Upload the fetched files to SharePoint and gather statistics
+        upload_statistics = await self.upload_thies_files_to_sharepoint(
+            thies_fetched_files
+        )
+
+        return parse_execute_response(thies_fetched_files, upload_statistics)

saviialib/services/epii/utils/__init__.py

@@ -0,0 +1,3 @@
+from .update_thies_data_utils import parse_execute_response
+
+__all__ = ["parse_execute_response"]

saviialib/services/epii/utils/update_thies_data_utils.py

@@ -0,0 +1,21 @@
+from typing import Any
+
+from saviialib.libs.zero_dependency.utils.datetime_utils import (
+    datetime_to_str,
+    today,
+)
+
+
+def parse_execute_response(
+    thies_fetched_files: dict[str, Any], upload_statistics: dict[str, Any]
+) -> dict[str, dict[str, int | str]]:
+    return {
+        **upload_statistics,
+        "processed_files": {
+            filename: {
+                "file_size": len(data),
+                "processed_date": datetime_to_str(today()),
+            }
+            for filename, data in thies_fetched_files.items()
+        },
+    }

saviialib-0.6.1.dist-info/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025, pedropablozavalat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

saviialib-0.6.1.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.3
+Name: saviialib
+Version: 0.6.1
+Summary: A client library for IoT projects in the RCER initiative
+License: MIT
+Author: pedropablozavalat
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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: aioftp (==0.25.1)
+Requires-Dist: aiohttp (==3.11.16)
+Requires-Dist: build
+Requires-Dist: dotenv (==0.9.9)
+Requires-Dist: pydantic (==2.11.3)
+Requires-Dist: pytest-cov (==6.1.1)
+Description-Content-Type: text/markdown
+
+# SAVIIA Library 
+*Sistema de Administración y Visualización de Información para la Investigación y Análisis*
+
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/pedrozavalat/saviia-lib?style=for-the-badge)](https://github.com/pedrozavalat/saviia-lib/releases)
+
+
+## Installation
+This library is designed for use with the SAVIIA Home Assistant Integration. It provides an API to retrieve files from a THIES Data Logger via an FTP server and upload them to a Microsoft SharePoint folder using the SharePoint REST API.
+
+```bash
+pip install saviialib
+```
+
+## Usage
+
+### Initialize the EPii API Client
+To start using the library, you need to create an `EpiiAPI` client instance:
+
+```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(
+        ftp_port=FTP_PORT,
+        ftp_host=FTP_HOST,
+        ftp_user=FTP_USER,
+        ftp_password=FTP_PASSWORD,
+        sharepoint_client_id=SHAREPOINT_CLIENT_ID,
+        sharepoint_client_secret=SHAREPOINT_CLIENT_SECRET,
+        sharepoint_tenant_id=SHAREPOINT_TENANT_ID,
+        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())
+```
+
+**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.
+
+## Development
+
+This project includes a `Makefile` to simplify common tasks. Below are the available commands:
+
+### Install Basic Dependencies
+To install the basic dependencies required for the project, run the following command:
+
+```bash
+make install-deps
+```
+
+This will ensure that all necessary libraries and tools are installed for the project to function properly.
+
+### Install Development Requirements
+For setting up a development environment with additional tools and libraries, execute:
+
+```bash
+make dev
+```
+
+This command installs all the dependencies needed for development, including testing and linting tools.
+
+### Run Tests
+To verify that the code is functioning as expected, you can run the test suite using:
+
+```bash
+make test
+```
+
+This will execute all the tests in the project and provide a summary of the results.
+
+### Lint the Code
+To ensure that the code adheres to the project's style guidelines and is free of common errors, run:
+
+```bash
+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.
+
+## License
+
+`saviialib` was created by Pedro Pablo Zavala Tejos. It is licensed under the terms of the MIT license.
+

saviialib-0.6.1.dist-info/RECORD

@@ -0,0 +1,38 @@
+saviialib/__init__.py,sha256=_pFtnu8wiICE81UO5XRSgCwMwldbJ4wSeYO5A1P6fPM,278
+saviialib/general_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+saviialib/general_types/api/__init__.py,sha256=Dmy5H7Mm4n-ewj3dC1wzM5o-379Ebeb9hnBOqq8M4IE,96
+saviialib/general_types/api/update_thies_data_types.py,sha256=1ZTjHSSfmhOp9wAHOMHfQxoibiNKN05PdpRrXUcd2JQ,1077
+saviialib/general_types/error_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+saviialib/general_types/error_types/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+saviialib/general_types/error_types/api/update_thies_data_error_types.py,sha256=YkbMXzg3B2fD-L-sh6f__6uZQ9nkvN6rUacchcPpJn8,1690
+saviialib/general_types/error_types/common/__init__.py,sha256=yOBLZbt64Ki9Q0IJ0tMAubgq7PtrQ7XQ3RgtAzyOjiE,170
+saviialib/general_types/error_types/common/common_types.py,sha256=n5yuw-gVtkrtNfmaZ83ZkYxYHGl4jynOLUB9C8Tr32w,474
+saviialib/libs/ftp_client/__init__.py,sha256=dW2Yutgc7mJJJzgKLhWKXMgQ6KIWJYfFa1sGpjHH5xU,191
+saviialib/libs/ftp_client/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+saviialib/libs/ftp_client/clients/aioftp_client.py,sha256=gcPhLX1EE8_iiAGQ1eTWxzJ-qd3yjP9Ug1LJPibqGn8,1613
+saviialib/libs/ftp_client/ftp_client.py,sha256=RhWnGwfU8SN0tRqfDc3u6NKDj9qla4cOI2IANyb-S2s,820
+saviialib/libs/ftp_client/ftp_client_contract.py,sha256=2x1MPZNFVw3l-sVd65Z6kZYkXlk_8isH_ykzRZB9Cv8,326
+saviialib/libs/ftp_client/types/__init__.py,sha256=syfwf9feP4QK7fkCTfl4j8l11ic-jHtfi1DE2chaWbs,155
+saviialib/libs/ftp_client/types/ftp_client_types.py,sha256=e4SmYkewldulaD8ms2q75zVgLFXyBxBqoa_L-IQOmso,256
+saviialib/libs/sharepoint_client/__init__.py,sha256=v7h-cNsK-BaPp-hTU3NWRNXYRD9ztU-hsCk0eNRPIKA,334
+saviialib/libs/sharepoint_client/clients/sharepoint_rest_api.py,sha256=6TGw2svGZ9QiABJdiUNzTIjmla3f70-hVxPK0cOZEVc,5252
+saviialib/libs/sharepoint_client/sharepoint_client.py,sha256=lzzRk-5YzScNL15TzHp8dAcdhiAtRVCfY7L2GEqoccM,1246
+saviialib/libs/sharepoint_client/sharepoint_client_contract.py,sha256=xqNHzCjp7GvUGGUox9YTJj2QJgTc5819t2etOk8X26o,485
+saviialib/libs/sharepoint_client/types/sharepoint_client_types.py,sha256=OmPlCJ9rLrAFBeG6aDp5cxMiQ5BZlDyGVx5S4GN4aqg,414
+saviialib/libs/zero_dependency/utils/datetime_utils.py,sha256=kD38wC087H3jwTIgrntBajE55cR2ioo_ftPUHiyGs_M,751
+saviialib/services/epii/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+saviialib/services/epii/api.py,sha256=0CMxvl8AoDUqfE5bFxf7bnpvTcFYVRBtEXoRjxSghNk,1061
+saviialib/services/epii/constants/update_thies_data_constants.py,sha256=38f2WKV-zBO9O-CV8mh3tW3MFMiaJrrv4_FfQiyHApc,275
+saviialib/services/epii/controllers/__init__.py,sha256=mCdGgKGDgGxCtRoiZN9Rki-fTOyOuJWw9e7festpQYA,98
+saviialib/services/epii/controllers/types/__init__.py,sha256=xzky-oTSojLNkWETp_k8a4dcXYvYSQY0VhWo23Yhb8U,195
+saviialib/services/epii/controllers/types/update_thies_data_types.py,sha256=6r63NUTskYpaRrTG7V7yv2va0geHyONfnLxQu1XGEU0,389
+saviialib/services/epii/controllers/update_thies_data.py,sha256=8XeWJNfhwGCJ3Le5YKOnXRz9wKhVOTcfhqoCIIRG5PQ,4343
+saviialib/services/epii/use_cases/types/__init__.py,sha256=u6fyodOEJE2j6FMqJux40Xf9ccYAi-UUYxqT-Kzc0kE,199
+saviialib/services/epii/use_cases/types/update_thies_data_types.py,sha256=C0TU50KKYodpaX87OnG0MnHyGY4gRzmluUHk-esCEVU,635
+saviialib/services/epii/use_cases/update_thies_data.py,sha256=uBpk6i-snOpXL88to-64KHoJ5_ubdGpauAoUnlBzbPk,6734
+saviialib/services/epii/utils/__init__.py,sha256=cYt2tvq65_OMjFaqb8-CCC7IGCQgFd4ziEUWJV7s1iY,98
+saviialib/services/epii/utils/update_thies_data_utils.py,sha256=EpjYWXqyHxJ-dO3MHhdXp-rGV7WyUckeFko-nnfnNac,555
+saviialib-0.6.1.dist-info/LICENSE,sha256=NWpf6b38xgBWPBo5HZsCbdfp9hZSliEbRqWQgm0fkOo,1076
+saviialib-0.6.1.dist-info/METADATA,sha256=hMk2t2m8HMuwhslnLqlgRaUNMLkzBnAIC0pbzz3w77A,4134
+saviialib-0.6.1.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+saviialib-0.6.1.dist-info/RECORD,,

saviialib-0.6.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.2
+Root-Is-Purelib: true
+Tag: py3-none-any