rcer-iot-client-pkg 0.1.0__tar.gz

rcer_iot_client_pkg-0.1.0/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.
+

rcer_iot_client_pkg-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.3
+Name: rcer_iot_client_pkg
+Version: 0.1.0
+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
+
+# rcer_iot_client_pkg
+
+RCER IoT Client Library
+
+## Installation
+
+To install the package, run:
+
+```bash
+pip install rcer_iot_client_pkg
+```
+
+## 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
+
+`rcer_iot_client_pkg` was created by @pedrozavalat. It is licensed under the terms of the MIT license.
+

rcer_iot_client_pkg-0.1.0/README.md

@@ -0,0 +1,60 @@
+# rcer_iot_client_pkg
+
+RCER IoT Client Library
+
+## Installation
+
+To install the package, run:
+
+```bash
+pip install rcer_iot_client_pkg
+```
+
+## 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
+
+`rcer_iot_client_pkg` was created by @pedrozavalat. It is licensed under the terms of the MIT license.

rcer_iot_client_pkg-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[tool.poetry]
+name = "rcer_iot_client_pkg"
+version = "0.1.0"
+description = "A client library for IoT projects in the RCER initiative"
+authors = ["pedropablozavalat"]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+aioftp = "0.25.1"
+aiohttp = "3.11.16"
+pydantic = "2.11.3"
+dotenv = "0.9.9"
+pytest-cov="6.1.1"
+build="*"
+[tool.poetry.group.dev.dependencies]
+pytest = "8.3.5"
+pytest-asyncio = "0.26.0"
+black = "*"
+coverage = "*"
+flake8 = "*"
+pyflakes = "*"
+pylint = "*"
+build = "*"
+
+[tool.semantic_release]
+version_toml = [
+    "pyproject.toml:tool.poetry.version",
+]                                                    # version location
+branch = "main"                                      # branch to make releases of
+changelog_file = "CHANGELOG.md"                      # changelog file
+build_command = "pip install poetry && poetry build" # build dists 
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+line-length = 88
+target-version = "py311"
+exclude = ["venv", ".venv", "build", "dist", "__pycache__"]
+fix = true
+lint.ignore = ["E501"]  

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/__init__.py

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

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/general_types/error_types/api/update_thies_data_error_types.py

@@ -0,0 +1,19 @@
+class ThiesUploadEmptyError(Exception):
+    """Raised when no files are found to upload to the server."""
+
+    def __str__(self):
+        return "No files were found to upload."
+
+
+class FetchCloudFileNamesError(Exception):
+    """Raised when there is an error fetching file names from the RCER cloud."""
+
+    def __str__(self):
+        return "An error occurred while retrieving file names from the RCER cloud"
+
+
+class FetchThiesFileContentError(Exception):
+    """Raised when there is an error fetching the content of a Thies file."""
+
+    def __str__(self):
+        return "An error occurred while retrieving the content of a Thies file"

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/general_types/error_types/common/__init__.py

@@ -0,0 +1,7 @@
+from src.rcer_iot_client_pkg.general_types.error_types.common.common_types import (
+    EmptyDataError,
+    FtpClientError,
+    HttpClientError,
+)
+
+__all__ = ["EmptyDataError", "HttpClientError", "FtpClientError"]

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/general_types/error_types/common/common_types.py

@@ -0,0 +1,13 @@
+class EmptyDataError(Exception):
+    def __str__(self):
+        return "The data provided is empty."
+
+
+class HttpClientError(Exception):
+    def __str__(self):
+        return "Http Client initialization fails."
+
+
+class FtpClientError(Exception):
+    def __str__(self):
+        return "Ftp Client initialization fails."

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/libs/async_http_client/__init__.py

@@ -0,0 +1,10 @@
+"""Export defined type classes."""
+
+from .async_http_client import AsyncHTTPClient
+from .types.async_http_client_types import (
+    AsyncHttpClientInitArgs,
+    GetArgs,
+    UploadFileArgs,
+)
+
+__all__ = ["AsyncHTTPClient", "AsyncHttpClientInitArgs", "GetArgs", "UploadFileArgs"]

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/libs/async_http_client/async_http_client.py

@@ -0,0 +1,34 @@
+from typing import Any
+
+from .async_http_client_contract import AsyncHTTPClientContract
+from .clients.aiohttp_client import AioHttpClient
+from .types.async_http_client_types import (
+    AsyncHttpClientInitArgs,
+    GetArgs,
+    UploadFileArgs,
+)
+
+
+class AsyncHTTPClient(AsyncHTTPClientContract):
+    CLIENTS = {"aiohttp_client"}
+
+    def __init__(self, args: AsyncHttpClientInitArgs) -> None:
+        if args.client_name not in AsyncHTTPClient.CLIENTS:
+            msg = f"Unsupported client '{args.client_name}'"
+            raise KeyError(msg)
+        self.client_name = args.client_name
+
+        if args.client_name == "aiohttp_client":
+            self.client_obj = AioHttpClient(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 get(self, args: GetArgs) -> dict[str, Any]:
+        return await self.client_obj.get(args)
+
+    async def upload_file(self, args: UploadFileArgs) -> dict[str, Any]:
+        return await self.client_obj.upload_file(args)

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/libs/async_http_client/async_http_client_contract.py

@@ -0,0 +1,29 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from .types.async_http_client_types import GetArgs, UploadFileArgs
+
+
+class AsyncHTTPClientContract(ABC):
+    """
+    A contract for asynchronous HTTP client implementations.
+
+    This abstract base class defines the required methods for performing
+    HTTP GET requests and uploading files asynchronously.
+
+    Methods.
+    -------
+    get(args: GetArgs) -> dict[str, Any]
+        Perform an HTTP GET request with the specified arguments.
+
+    upload_file(args: UploadFileArgs) -> dict[str, Any]
+        Upload a file using the specified arguments.
+    """
+
+    @abstractmethod
+    async def get(self, args: GetArgs) -> dict[str, Any]:
+        pass
+
+    @abstractmethod
+    async def upload_file(self, args: UploadFileArgs) -> dict[str, Any]:
+        pass

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/libs/async_http_client/clients/aiohttp_client.py

@@ -0,0 +1,50 @@
+from typing import Any
+
+from aiohttp import ClientError, ClientSession
+
+from src.rcer_iot_client_pkg.libs.async_http_client.async_http_client_contract import (
+    AsyncHTTPClientContract,
+)
+from src.rcer_iot_client_pkg.libs.async_http_client.types.async_http_client_types import (
+    AsyncHttpClientInitArgs,
+    GetArgs,
+    UploadFileArgs,
+)
+
+
+class AioHttpClient(AsyncHTTPClientContract):
+    def __init__(self, args: AsyncHttpClientInitArgs) -> None:
+        self.access_token = args.access_token
+        self.base_url = args.base_url
+        self.headers = self._build_headers()
+        self.session: ClientSession | None = None
+
+    def _build_headers(self) -> dict:
+        return {"Authorization": f"Bearer {self.access_token}"}
+
+    async def __aenter__(self) -> "AioHttpClient":
+        self.session = ClientSession(headers=self.headers, base_url=self.base_url)
+        return self
+
+    async def __aexit__(
+        self, _exc_type: type[BaseException], _exc_val: BaseException, _exc_tb: Any
+    ) -> None:
+        await self.session.close()
+
+    async def get(self, args: GetArgs) -> dict[str, Any]:
+        try:
+            endpoint, params = args.endpoint.lstrip("/"), args.params
+            response = await self.session.get(endpoint, params=params)
+            response.raise_for_status()
+            return await response.json()
+        except ClientError as error:
+            raise ConnectionError(error) from error
+
+    async def upload_file(self, args: UploadFileArgs) -> dict[str, Any]:
+        try:
+            endpoint, file_bytes = args.endpoint.lstrip("/"), args.file_bytes
+            response = await self.session.put(endpoint, data=file_bytes)
+            response.raise_for_status()
+            return await response.json()
+        except ClientError as error:
+            raise ConnectionError(error) from error

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/libs/async_http_client/types/__init__.py

@@ -0,0 +1,3 @@
+from .async_http_client_types import AsyncHttpClientInitArgs, GetArgs, UploadFileArgs
+
+__all__ = ["AsyncHttpClientInitArgs", "GetArgs", "UploadFileArgs"]

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/libs/async_http_client/types/async_http_client_types.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel, Field
+
+
+class AsyncHttpClientInitArgs(BaseModel):
+    access_token: str
+    base_url: str
+    client_name: str = "aiohttp_client"
+
+
+class GetArgs(BaseModel):
+    endpoint: str
+    params: dict | None = Field(default=None)
+
+
+class UploadFileArgs(BaseModel):
+    endpoint: str
+    file_bytes: bytes

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/libs/ftp_client/__init__.py

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

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/libs/ftp_client/clients/aioftp_client.py

@@ -0,0 +1,34 @@
+from aioftp import Client
+
+from src.rcer_iot_client_pkg.libs.ftp_client.ftp_client_contract import (
+    FTPClientContract,
+)
+from src.rcer_iot_client_pkg.libs.ftp_client.types.ftp_client_types import (
+    FtpClientInitArgs,
+    ListFilesArgs,
+    ReadFileArgs,
+)
+
+
+class AioFTPClient(FTPClientContract):
+    def __init__(self, args: FtpClientInitArgs) -> None:
+        self.host = args.host
+        self.port = args.port
+        self.password = args.password
+        self.user = args.user
+        self.client = Client()
+
+    async def _async_start(self) -> None:
+        await self.client.connect(host=self.host, port=self.port)
+        await self.client.login(user=self.user, password=self.password)
+
+    async def list_files(self, args: ListFilesArgs) -> 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: ReadFileArgs) -> bytes:
+        await self._async_start()
+        async with self.client.download_stream(args.file_path) as stream:
+            return await stream.read()

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/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, ListFilesArgs, ReadFileArgs
+
+
+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: ListFilesArgs) -> list[str]:
+        return self.client_obj.list_files(args)
+
+    def read_file(self, args: ReadFileArgs) -> bytes:
+        return self.client_obj.read_file(args)

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/libs/ftp_client/ftp_client_contract.py

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

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/libs/ftp_client/types/__init__.py

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

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/libs/ftp_client/types/ftp_client_types.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class FtpClientInitArgs:
+    host: str
+    user: str
+    password: str
+    client_name: str = "aioftp_client"
+    port: int = 21
+
+
+@dataclass
+class ListFilesArgs:
+    path: str
+
+
+@dataclass
+class ReadFileArgs:
+    file_path: str

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/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)

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/services/epii/api.py

@@ -0,0 +1,23 @@
+from typing import Dict
+
+from src.rcer_iot_client_pkg.services.epii.controllers import UpdateThiesDataController
+from src.rcer_iot_client_pkg.services.epii.controllers.types import UpdateThiesDataControllerInput
+
+class EpiiAPI:
+    def update_thies_data(
+        self,
+        ftp_port: int,
+        ftp_host: str,
+        ftp_password: str,
+        ftp_user: str,
+    ) -> Dict[str, any]:
+        controller = UpdateThiesDataController(
+            UpdateThiesDataControllerInput(
+                ftp_port=ftp_port,
+                ftp_host=ftp_host,
+                ftp_password=ftp_password,
+                ftp_user=ftp_user,
+            )
+        )
+        response = controller.execute()
+        return response.__dict__

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/services/epii/controllers/__init__.py

@@ -0,0 +1,5 @@
+from src.rcer_iot_client_pkg.services.epii.controllers.update_thies_data import (
+    UpdateThiesDataController,
+)
+
+__all__ = ["UpdateThiesDataController"]

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/services/epii/controllers/types/__init__.py

@@ -0,0 +1,6 @@
+from src.rcer_iot_client_pkg.services.epii.controllers.types.update_thies_data_types import (
+    UpdateThiesDataControllerInput,
+    UpdateThiesDataControllerOutput,
+)
+
+__all__ = ["UpdateThiesDataControllerInput", "UpdateThiesDataControllerOutput"]

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/services/epii/controllers/types/update_thies_data_types.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass, field
+from typing import Dict
+
+
+@dataclass
+class UpdateThiesDataControllerInput:
+    ftp_host: str
+    ftp_port: str
+    ftp_user: str
+    ftp_password: str
+
+
+@dataclass
+class UpdateThiesDataControllerOutput:
+    message: str
+    status: int
+    metadata: Dict[str, str] = field(default_factory=dict)

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/services/epii/controllers/update_thies_data.py

@@ -0,0 +1,68 @@
+from http import HTTPStatus
+
+from src.rcer_iot_client_pkg.general_types.error_types.api.update_thies_data_error_types import (
+    FetchCloudFileNamesError,
+    ThiesUploadEmptyError,
+)
+from src.rcer_iot_client_pkg.general_types.error_types.common import (
+    FtpClientError,
+    HttpClientError,
+)
+from src.rcer_iot_client_pkg.services.epii.controllers.types.update_thies_data_types import (
+    UpdateThiesDataControllerInput,
+    UpdateThiesDataControllerOutput,
+)
+from src.rcer_iot_client_pkg.services.epii.use_cases.types import (
+    UpdateThiesDataUseCaseInput,
+)
+from src.rcer_iot_client_pkg.services.epii.use_cases.update_thies_data import (
+    UpdateThiesDataUseCase,
+)
+
+
+class UpdateThiesDataController:
+    def __init__(self, input: UpdateThiesDataControllerInput):
+        self.use_case = UpdateThiesDataUseCase(
+            UpdateThiesDataUseCaseInput(**input.__dict__)
+        )
+
+    async def execute(self) -> UpdateThiesDataControllerOutput:
+        try:
+            data = await self.use_case.execute()
+            return UpdateThiesDataControllerOutput(
+                message="THIES was synced successfully",
+                status=HTTPStatus.OK,
+                metadata={"data": data},
+            )
+        except (AttributeError, NameError, ValueError) as error:
+            return UpdateThiesDataControllerOutput(
+                message="An unexpected error occurred during use case initialization.",
+                status=HTTPStatus.BAD_REQUEST,
+                metadata={"error": error.__str__()},
+            )
+        except FtpClientError as error:
+            return UpdateThiesDataControllerOutput(
+                message="Ftp Client initialization fails.",
+                status=HTTPStatus.INTERNAL_SERVER_ERROR,
+                metadata={"error": error.__str__()},
+            )
+
+        except HttpClientError as error:
+            return UpdateThiesDataControllerOutput(
+                message="Http Client initialization fails.",
+                status=HTTPStatus.INTERNAL_SERVER_ERROR,
+                metadata={"error": error.__str__()},
+            )
+
+        except FetchCloudFileNamesError as error:
+            return UpdateThiesDataControllerOutput(
+                message="An error occurred while retrieving file names from the RCER cloud",
+                status=HTTPStatus.INTERNAL_SERVER_ERROR,
+                metadata={"error": error.__str__()},
+            )
+        except ThiesUploadEmptyError as error:
+            return UpdateThiesDataControllerOutput(
+                message="No files were found to upload.",
+                status=HTTPStatus.NO_CONTENT,
+                metadata={"error": error.__str__()},
+            )

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/services/epii/use_cases/constants.py

@@ -0,0 +1,4 @@
+PATH_AVG_FILES = "ftp/thies/BINFILES/ARCH_AV1"
+PATH_EXT_FILES = "ftp/thies/BINFILES/ARCH_EX1"
+DRIVE_ID = "b!Row14jaFrU-1q8qzrvj3OmPPTYWXizFEpJmI-wsfH5pXxA0qQwgQS50m2xvPCZem"
+FILE_TYPES = ["AVG", "EXT"]

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/services/epii/use_cases/types/__init__.py

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

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/services/epii/use_cases/types/update_thies_data_types.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass, field
+from typing import Dict
+
+
+@dataclass
+class UpdateThiesDataUseCaseInput:
+    ftp_host: str
+    ftp_port: str
+    ftp_user: str
+    ftp_password: str
+
+
+@dataclass
+class UpdateThiesDataUseCaseOutput:
+    message: str
+    status: int = 0
+    metadata: Dict[str, str] = field(default_factory=dict)

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/services/epii/use_cases/update_thies_data.py

@@ -0,0 +1,135 @@
+import os
+
+from dotenv import load_dotenv
+
+import src.rcer_iot_client_pkg.services.epii.use_cases.constants as c
+from src.rcer_iot_client_pkg.general_types.error_types.api.update_thies_data_error_types import (
+    FetchCloudFileNamesError,
+    FetchThiesFileContentError,
+    ThiesUploadEmptyError,
+)
+from src.rcer_iot_client_pkg.general_types.error_types.common import (
+    EmptyDataError,
+    FtpClientError,
+    HttpClientError,
+)
+from src.rcer_iot_client_pkg.libs.async_http_client import (
+    AsyncHTTPClient,
+    AsyncHttpClientInitArgs,
+    GetArgs,
+)
+from src.rcer_iot_client_pkg.libs.ftp_client import (
+    FTPClient,
+    FtpClientInitArgs,
+    ListFilesArgs,
+    ReadFileArgs,
+)
+from src.rcer_iot_client_pkg.services.epii.use_cases.types import (
+    UpdateThiesDataUseCaseInput,
+)
+from src.rcer_iot_client_pkg.services.epii.utils import (
+    generate_file_content,
+)
+
+load_dotenv()
+
+
+class UpdateThiesDataUseCase:
+    def __init__(self, input: UpdateThiesDataUseCaseInput):
+        self.ftp_port = input.ftp_port
+        self.ftp_host = input.ftp_host
+        self.ftp_password = input.ftp_password
+        self.ftp_user = input.ftp_user
+        self.sharepoint_client = self._initialize_sharepoint_client()
+        self.thies_ftp_client = self._initialize_thies_ftp_client()
+        self.uploading = set()
+
+    def _initialize_sharepoint_client(self) -> AsyncHTTPClient:
+        """Initialize the HTTP client."""
+        try:
+            return AsyncHTTPClient(
+                AsyncHttpClientInitArgs(
+                    client_name="aiohttp_client",
+                    access_token="temporal-token",
+                    base_url="https://graph.microsoft.com/v1.0/",
+                )
+            )
+        except Exception as error:
+            raise HttpClientError(error)
+
+    def _initialize_thies_ftp_client(self) -> FTPClient:
+        """Initialize the FTP client."""
+        try:
+            return FTPClient(
+                FtpClientInitArgs(
+                    client_name="aioftp_client",
+                    host=self.ftp_host,
+                    user=self.ftp_user,
+                    password=self.ftp_password,
+                    port=self.ftp_port,
+                )
+            )
+        except Exception as error:
+            raise FtpClientError(error)
+
+    async def fetch_cloud_file_names(self, folder_name: str) -> set[str]:
+        """Fetch file names from the RCER cloud."""
+        try:
+            cloud_files = set()
+            async with self.sharepoint_client:
+                for file_type in c.FILE_TYPES:
+                    destination_path = f"Onedrive_UC/noveno-semestre/IPRE-RCER/{folder_name}/{file_type}"
+                    endpoint = f"drives/{c.DRIVE_ID}/root:/{destination_path}:/children"
+                    response = await self.sharepoint_client.get(
+                        GetArgs(endpoint=endpoint)
+                    )
+                    cloud_files.update(
+                        {f"{file_type}_{item['name']}" for item in response["value"]}
+                    )
+            return cloud_files
+        except ConnectionError as error:
+            raise FetchCloudFileNamesError(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(
+                ListFilesArgs(path=c.PATH_AVG_FILES)
+            )
+            ext_files = await self.thies_ftp_client.list_files(
+                ListFilesArgs(path=c.PATH_EXT_FILES)
+            )
+            return {f"AVG_{name}" for name in avg_files} | {
+                f"EXT_{name}" for name in ext_files
+            }
+        except ConnectionError:
+            raise ThiesUploadEmptyError
+
+    async def fetch_thies_file_content(self) -> dict[str, bytes]:
+        """Fetch the content of files from the THIES FTP server."""
+        content_files = {}
+        for file in self.uploading:
+            try:
+                origin, filename = file.split("_", 1)
+                file_path = (
+                    f"{c.PATH_AVG_FILES}/{filename}"
+                    if origin == "AVG"
+                    else f"{c.PATH_EXT_FILES}/{filename}"
+                )
+                content = await self.thies_ftp_client.read_file(ReadFileArgs(file_path))
+                content_files[filename] = content
+            except ConnectionError as error:
+                raise FetchThiesFileContentError(error)
+        return content_files
+
+    async def execute(self) -> dict:
+        """Synchronize data from the THIES Center to the cloud."""
+        thies_files = await self.fetch_thies_file_names()
+        cloud_files = await self.fetch_cloud_file_names(folder_name="thies")
+        self.uploading = thies_files - cloud_files
+        if not self.uploading:
+            raise EmptyDataError
+
+        thies_file_contents = await self.fetch_thies_file_content()
+        data = generate_file_content(thies_file_contents)
+        return data

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/services/epii/utils/__init__.py

@@ -0,0 +1,3 @@
+from src.rcer_iot_client_pkg.services.epii.utils.update_thies_data_utils import generate_file_content
+
+__all__ = ["generate_file_content"]

rcer_iot_client_pkg-0.1.0/src/rcer_iot_client_pkg/services/epii/utils/update_thies_data_utils.py

@@ -0,0 +1,18 @@
+from typing import Any
+
+from src.rcer_iot_client_pkg.libs.zero_dependency.utils.datetime_utils import (
+    datetime_to_str,
+    today,
+)
+
+
+def generate_file_content(
+    file_contents: dict[str, Any],
+) -> dict[str, dict[str, int | str]]:
+    return {
+        filename: {
+            "size": len(data),
+            "date": datetime_to_str(today()),
+        }
+        for filename, data in file_contents.items()
+    }