saviialib 1.6.1__py3-none-any.whl

saviialib/services/thies/use_cases/update_thies_data.py

@@ -0,0 +1,391 @@
+from saviialib.general_types.error_types.api.saviia_api_error_types import (
+    SharePointFetchingError,
+    SharePointDirectoryError,
+    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,
+    SpListFoldersArgs,
+    SpUploadFileArgs,
+)
+from saviialib.libs.directory_client import DirectoryClient, DirectoryClientArgs
+
+from saviialib.libs.files_client import (
+    FilesClient,
+    FilesClientInitArgs,
+    WriteArgs,
+    ReadArgs,
+)
+from saviialib.services.backup.use_cases.types import (
+    FtpClientConfig,
+    SharepointConfig,
+    UpdateThiesDataUseCaseInput,
+)
+from saviialib.services.backup.utils import (
+    parse_execute_response,
+)
+from saviialib.libs.zero_dependency.utils.datetime_utils import today, datetime_to_str
+from .components.create_thies_statistics_file import create_thies_daily_statistics_file
+from typing import Set, Dict, List
+
+
+class UpdateThiesDataUseCase:
+    BASE_FOLDER_NAME = "thies"
+
+    def __init__(self, input: UpdateThiesDataUseCaseInput):
+        self.sharepoint_client = self._initialize_sharepoint_client(
+            input.sharepoint_config
+        )
+        self.logger = input.logger
+        self.thies_ftp_client = self._initialize_thies_ftp_client(input.ftp_config)
+        self.sharepoint_folders_path = input.sharepoint_folders_path
+        self.ftp_server_folders_path = input.ftp_server_folders_path
+        self.local_backup_path = input.local_backup_source_path
+        self.sharepoint_base_url = f"/sites/{self.sharepoint_client.site_name}"
+        self.uploading = set()
+        self.os_client = self._initialize_os_client()
+        self.files_client = self._initialize_files_client()
+
+    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="ftplib_client"))
+        except RuntimeError as error:
+            raise FtpClientError(error)
+
+    def _initialize_os_client(self) -> DirectoryClient:
+        return DirectoryClient(DirectoryClientArgs(client_name="os_client"))
+
+    def _initialize_files_client(self) -> FilesClient:
+        return FilesClient(FilesClientInitArgs(client_name="aiofiles_client"))
+
+    async def _validate_sharepoint_current_folders(self):
+        async with self.sharepoint_client:
+            folder_base_path = "/".join(
+                self.sharepoint_folders_path[0].split("/")[0:-1]
+            )
+            relative_url = f"{self.sharepoint_base_url}/{folder_base_path}"
+            response = await self.sharepoint_client.list_folders(
+                SpListFoldersArgs(relative_url)
+            )
+
+        current_folders = [item["Name"] for item in response["value"]]  # type: ignore
+
+        for folder_path in self.sharepoint_folders_path:
+            folder_name = folder_path.split("/")[-1]
+            if folder_name not in current_folders:
+                raise SharePointDirectoryError(
+                    reason=f"The current folder '{folder_name}' doesn't exist."
+                )
+
+    async def fetch_cloud_file_names(self) -> Set[str]:
+        """Fetch file names from the RCER cloud."""
+        await self._validate_sharepoint_current_folders()
+        try:
+            cloud_files = set()
+            async with self.sharepoint_client:
+                for folder_path in self.sharepoint_folders_path:
+                    folder_name = folder_path.split("/")[-1]
+                    relative_url = f"{self.sharepoint_base_url}/{folder_path}"
+                    args = SpListFilesArgs(folder_relative_url=relative_url)
+                    response = await self.sharepoint_client.list_files(args)
+                    cloud_files.update(
+                        {
+                            (f"{folder_name}_{item['Name']}", int(item["Length"]))
+                            for item in response["value"]  # type: ignore
+                        }  # type: ignore
+                    )
+            return cloud_files
+        except Exception as error:
+            raise SharePointFetchingError(reason=error)
+
+    async def fetch_thies_file_names(self) -> Set[str]:
+        """Fetch file names from the THIES FTP server."""
+        try:
+            thies_files = set()
+            for folder_path in self.ftp_server_folders_path:
+                # AV for average, and EXT for extreme.
+                prefix = "AVG" if "AV" in folder_path else "EXT"
+                files = await self.thies_ftp_client.list_files(
+                    FtpListFilesArgs(path=folder_path)
+                )
+                files_names = {(f"{prefix}_{name}", size) for name, size in files}
+                thies_files.update(files_names)
+            return thies_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:
+                prefix, filename = file.split("_", 1)
+                file_path = self.os_client.join_paths(
+                    self.local_backup_path,
+                    UpdateThiesDataUseCase.BASE_FOLDER_NAME,
+                    prefix,
+                    filename,
+                )
+                content = await self.files_client.read(
+                    ReadArgs(file_path=file_path, mode="rb")
+                )
+                self.logger.debug(
+                    "[thies_synchronization_lib] Fetching file '%s' from '%s'.",
+                    file,
+                    file_path,
+                )
+                # Save file content with its original name.
+                content_files[file] = content
+            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": [], "new_files": []}
+
+        async with self.sharepoint_client:
+            for file, file_content in files.items():
+                try:
+                    origin, file_name = file.split("_", 1)
+                    # Check if the first folder is for AVG, otherwise assume it's for EXT
+                    if "AVG" in self.sharepoint_folders_path[0]:
+                        avg_folder = self.sharepoint_folders_path[0]
+                        ext_folder = self.sharepoint_folders_path[1]
+                    else:
+                        avg_folder = self.sharepoint_folders_path[1]
+                        ext_folder = self.sharepoint_folders_path[0]
+                    folder_path = avg_folder if origin == "AVG" else ext_folder
+                    relative_url = f"{self.sharepoint_base_url}/{folder_path}"
+                    await self.sharepoint_client.upload_file(
+                        SpUploadFileArgs(
+                            folder_relative_url=relative_url,
+                            file_content=file_content,
+                            file_name=file_name,
+                        )
+                    )
+                    upload_results["new_files"].append(file)
+                    self.logger.debug(
+                        "[thies_synchronization_lib] File '%s' uploaded successfully to '%s' ✅",
+                        file_name,
+                        relative_url,
+                    )
+
+                except ConnectionError as error:
+                    self.logger.error(
+                        "[thies_synchronization_lib] Unexpected error from with file '%s'",
+                        file_name,
+                    )
+                    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 _sync_pending_files(self, thies_files: set, cloud_files: set) -> set:
+        thies_files_dict = {name: size for name, size in thies_files}
+        cloud_files_dict = {name: size for name, size in cloud_files}
+        uploading = set()
+        for f_from_thies, f_size_from_thies in thies_files_dict.items():
+            # If is in thies but not in cloud, then upload it
+            if f_from_thies not in cloud_files_dict:
+                uploading.add(f_from_thies)
+            else:
+                # If the file is in both services, but the size is different, then upload it
+                f_size_from_cloud = cloud_files_dict[f_from_thies]
+                if f_size_from_thies != f_size_from_cloud:
+                    uploading.add(f_from_thies)
+        return uploading
+
+    async def _extract_thies_daily_statistics(self) -> None:
+        # Read the daily files and save each data in the folder
+        daily_files = [
+            prefix + datetime_to_str(today(), date_format="%Y%m%d") + ".BIN"
+            for prefix in ["AVG_", "EXT_"]
+        ]
+        # Receive from FTP server and  write the file in thies-daily-files
+        for file in daily_files:
+            prefix, filename = file.split("_", 1)
+            # The first path is for AVG files. The second file is for EXT files
+            file_path = self.os_client.join_paths(
+                self.local_backup_path, UpdateThiesDataUseCase.BASE_FOLDER_NAME, prefix
+            )
+            files = await self.os_client.listdir(file_path)
+            if filename not in files:
+                reason = "The file might not be available yet for statistics."
+                self.logger.warning("[thies_synchronization_lib] Warning: %s", reason)
+                self.logger.warning(
+                    "[thies_synchronization_lib] Skipping the creation of daily statistics %s",
+                    filename,
+                )
+                return
+        await create_thies_daily_statistics_file(
+            self.local_backup_path, self.os_client, self.logger
+        )
+
+    async def _validate_local_backup(self):
+        backup_path = self.os_client.join_paths(
+            self.local_backup_path, UpdateThiesDataUseCase.BASE_FOLDER_NAME
+        )
+        backup_dir_exists = await self.os_client.path_exists(backup_path)
+        if not backup_dir_exists:
+            await self.os_client.makedirs(backup_path)
+
+        for dest_folder in {"AVG", "EXT"}:
+            dest_folder_path = self.os_client.join_paths(backup_path, dest_folder)
+            dest_folder_exists = await self.os_client.path_exists(dest_folder_path)
+            if not dest_folder_exists:
+                await self.os_client.makedirs(
+                    self.os_client.join_paths(backup_path, dest_folder)
+                )
+
+    async def _fill_local_backup(self, thies_files: Set[str]) -> None:
+        local_avg_files = await self.os_client.listdir(
+            self.os_client.join_paths(
+                self.local_backup_path, UpdateThiesDataUseCase.BASE_FOLDER_NAME, "AVG"
+            ),
+            more_info=True,
+        )
+        local_avg_files = {filename: size for filename, size in local_avg_files}
+        local_ext_files = await self.os_client.listdir(
+            self.os_client.join_paths(
+                self.local_backup_path, UpdateThiesDataUseCase.BASE_FOLDER_NAME, "EXT"
+            ),
+            more_info=True,
+        )
+        local_ext_files = {filename: size for filename, size in local_ext_files}
+        try:
+            for file, orig_size in thies_files:
+                prefix, filename = file.split("_", 1)
+                # The first path is for AVG files. The second file is for EXT files
+                folder_path = next(
+                    (
+                        path
+                        for path in self.ftp_server_folders_path
+                        if prefix == ("AVG" if "AV" in path else "EXT")
+                    ),
+                    self.ftp_server_folders_path[0],  # Default to the first path
+                )
+                dest_path = self.os_client.join_paths(
+                    self.local_backup_path,
+                    UpdateThiesDataUseCase.BASE_FOLDER_NAME,
+                    prefix,
+                )
+                new_size = (
+                    local_avg_files.get(filename, None)
+                    if prefix == "AVG"
+                    else local_ext_files.get(filename, None)
+                )
+                should_be_added = False
+                if new_size and new_size != orig_size:
+                    should_be_added = True
+                elif not new_size:
+                    should_be_added = True
+                else:
+                    # Should not be added, because it has the same size and it's saved in the local dir.
+                    pass
+
+                if not should_be_added:
+                    continue
+
+                self.logger.debug(
+                    f"[thies_synchronization_lib] Saving {filename} in Thies local backup"
+                )
+                file_path = f"{folder_path}/{filename}"
+                file_content = await self.thies_ftp_client.read_file(
+                    FtpReadFileArgs(file_path)
+                )
+                await self.files_client.write(
+                    WriteArgs(
+                        file_name=filename,
+                        file_content=file_content,
+                        mode="wb",
+                        destination_path=dest_path,
+                    )
+                )
+        except ConnectionRefusedError as error:
+            raise ThiesConnectionError(reason=error)
+        except ConnectionAbortedError as error:
+            raise ThiesFetchingError(reason=error)
+
+    async def execute(self):
+        """Synchronize data from the THIES Center to the cloud."""
+        self.logger.debug("[thies_synchronization_lib] Starting ...")
+        await self._validate_local_backup()
+        try:
+            thies_files = await self.fetch_thies_file_names()
+            await self._fill_local_backup(thies_files)
+        except RuntimeError as error:
+            raise FtpClientError(error)
+        self.logger.debug(
+            "[thies_synchronization_lib] Total files fetched from THIES: %s",
+            str(len(thies_files)),
+        )
+        try:
+            cloud_files = await self.fetch_cloud_file_names()
+        except RuntimeError as error:
+            raise SharepointClient(error)  # type: ignore
+        self.logger.debug(
+            "[thies_synchronization_lib] Total files fetched from Sharepoint: %s",
+            str(len(cloud_files)),
+        )
+        self.uploading = await self._sync_pending_files(thies_files, cloud_files)
+        # Extract thies statistics for SAVIIA Sensors
+        await self._extract_thies_daily_statistics()
+        if not self.uploading:
+            raise EmptyDataError(reason="No files to upload.")
+        self.logger.debug(
+            "[thies_synchronization_lib] Total new files to upload: %s",
+            str(len(self.uploading)),
+        )
+        # 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
+        )
+        self.logger.info(upload_statistics)
+        self.logger.debug(
+            "[thies_synchronization_lib] All the files were uploaded successfully 🎉"
+        )
+
+        return parse_execute_response(thies_fetched_files, upload_statistics)  # type: ignore

saviialib/services/thies/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-1.6.1.dist-info/METADATA

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: saviialib
+Version: 1.6.1
+Summary: A client library for IoT projects in the RCER initiative
+License: MIT
+License-File: LICENSE
+Author: pedropablozavalat
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: aiofiles
+Requires-Dist: aioftp
+Requires-Dist: aiohttp
+Requires-Dist: asyncssh (==2.21.1)
+Requires-Dist: bitarray
+Requires-Dist: build
+Requires-Dist: certifi
+Requires-Dist: dotenv (>=0.9.9,<0.10.0)
+Requires-Dist: ffmpeg-asyncio (==0.1.3)
+Requires-Dist: numpy (>=2.2.0,<2.4.0)
+Requires-Dist: pandas (>=2.2.3,<2.3.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
+```
+
+## Saviia API Client Usage
+
+### Initialize the Saviia API Client
+Import the necessary classes from the library.
+```python
+from saviialib import SaviiaAPI, SaviiaAPIConfig
+```
+
+To start using the library, you need to create an `SaviiaAPI` client instance with its configuration class `SaviiaAPIConfig`. Provide the required parameters such as FTP server details and SharePoint credentials:
+```python
+config = SaviiaAPIConfig(
+    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
+)
+```
+```python
+api_client = SaviiaAPI(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.
+
+### Access THIES Data Logger Services
+To interact with the THIES Data Logger services, you can access the `thies` attribute of the `SaviiaAPI` instance:
+```python
+thies_client = api_client.get('thies')
+```
+This instance provides methods to interact with the THIES Data Logger. Currently, it includes the main method for extracting files from the FTP server and uploading them to SharePoint.
+
+#### THIES files extraction and synchronization
+The library provides a method to extract and synchronize THIES Data Logger files with the Microsoft SharePoint client. This method downloads files from the FTP server and uploads them to the specified SharePoint folder:
+```python 
+import asyncio
+async def main():
+    # Before calling this method, you must have initialised the THIES service class ...
+    response = await thies_client.update_thies_data()
+    return response
+
+asyncio.run(main())
+```
+
+### Access Backup Services
+To interact with the Backup services, you can access the `backup` attribute of the `SaviiaAPI` instance:
+```python
+backup_client = api_client.get('backup')
+```
+This instance provides methods to interact with the Backup services. Currently, it includes the main method for creating backups of specified directories in a local folder from Home Assistant environment. Then each backup file is uploaded to a Microsoft SharePoint folder.
+
+#### Create Backup
+The library provides a method which creates a backup of a specified directory in a local folder from Home Assistant environment. Then each backup file is uploaded to a Microsoft SharePoint folder: 
+
+```python
+import asyncio
+async def main():
+    # Before calling this method, you must have initialised the Backup service class ...
+    response = await backup_client.upload_backup_to_sharepoint(
+        local_backup_path=LOCAL_BACKUP_PATH,
+        sharepoint_folder_path=SHAREPOINT_FOLDER_PATH
+    )
+    return response
+asyncio.run(main())
+```
+**Notes:**
+- Ensure that the `local_backup_path` exists and contains the files you want to back up. It is a relative path from the Home Assistant configuration directory.
+- The `sharepoint_folder_path` should be the path to the folder in SharePoint where you want to upload the backup files. For example, if your url is `https://yourtenant.sharepoint.com/sites/yoursite/Shared Documents/Backups`, the folder path would be `sites/yoursite/Shared Documents/Backups`.
+
+
+
+
+
+
+
+## Contributing
+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` was created by Pedro Pablo Zavala Tejos. It is licensed under the terms of the MIT license.
+

saviialib-1.6.1.dist-info/RECORD

@@ -0,0 +1,91 @@
+saviialib/__init__.py,sha256=pn4KYFwPsVe43mw1e0svWiqA0StzM2B5Cr0iPc481I0,3074
+saviialib/general_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+saviialib/general_types/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+saviialib/general_types/api/saviia_api_types.py,sha256=kX45V3KQb48S1jEstXcAtbiemVUgemJE_XK5qP7BJm0,1318
+saviialib/general_types/api/saviia_backup_api_types.py,sha256=mtXRxFjBOqfUBWWtgLZxNq-vb_mBkCUS9fxoFRJfoYE,791
+saviialib/general_types/api/saviia_netcamera_api_types.py,sha256=WVA3VP_FiTGPhtTl8GCG2RAVo7YDS5TTyl-0I5rUK4Y,208
+saviialib/general_types/api/saviia_shakes_api_types.py,sha256=XlLwfCyFeQXk9kH7H0EcUJHIigj9edFKgn3wKGJ1Z94,623
+saviialib/general_types/api/saviia_thies_api_types.py,sha256=ueqOFjHvRuT-N8H1UZEVXErgK1S1iRw0AXeO8bTdBts,1017
+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/saviia_api_error_types.py,sha256=BcDhteS4KsFNCm3L9ZQJTQKs0bKRXq3LgM4mfxsW-HY,3270
+saviialib/general_types/error_types/api/saviia_netcamera_error_types.py,sha256=ipdY8PDJOFLxjgUIWc09cuaiHzPtBvAb7YKoosTL0wY,246
+saviialib/general_types/error_types/common/__init__.py,sha256=yOBLZbt64Ki9Q0IJ0tMAubgq7PtrQ7XQ3RgtAzyOjiE,170
+saviialib/general_types/error_types/common/common_types.py,sha256=2w790TQNRLc4UskXNHAh8RMZIJLA8FYyQbVxkPp89UA,717
+saviialib/libs/directory_client/__init__.py,sha256=ys07nzp74fHew2mUkbGpntp5w4t_PnhZIS6D4_mJw2A,162
+saviialib/libs/directory_client/client/os_client.py,sha256=9TqkwUJvK08twe_5Mun-Q5h0FLrJ6SUg5JCJI60VhkU,1726
+saviialib/libs/directory_client/directory_client.py,sha256=3CbKKtumYcZlIsH72MM0LZQVg_nn9ZQU8e03SExdyLA,1579
+saviialib/libs/directory_client/directory_client_contract.py,sha256=k1smoQPKQwBlM0xeLKghNzz2s2T5Q1KcEwExqFOpaVA,871
+saviialib/libs/directory_client/types/directory_client_types.py,sha256=ncMwVs_o6EYMuypXXmVInsjVDKJsdxVkmwj1M-LEInA,109
+saviialib/libs/files_client/__init__.py,sha256=sIi9ne7Z3EfxnqGTaSmH-cZ8QsKyu0hoOz61GyA3njs,192
+saviialib/libs/files_client/clients/aiofiles_client.py,sha256=nchUXaIzlpgDu0WNc3fsc0XS8o-tsTbiczBGvw0qgzQ,1633
+saviialib/libs/files_client/clients/csv_client.py,sha256=Rk4QbiKlVKrYxYtxQt-Pmkp9QoB_dNgs5r36JB9hU0o,1478
+saviialib/libs/files_client/files_client.py,sha256=oWfaMLA_Lw91H1_pPirFtFbdJh4abSyZp91qBsAiePs,950
+saviialib/libs/files_client/files_client_contract.py,sha256=fYvd68IMpc1OFkxbzNSmRUoTWVctf3hkNVQ7QZV0m6I,304
+saviialib/libs/files_client/types/files_client_types.py,sha256=z3ROStCjO-RtIqkoU8cCGYiaIYm8rxDheI5C0Vyl9lk,771
+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=eoTmf2y0i19G3f-jET7E_P9T2N_LF6CI0tAFfHbPMWM,1966
+saviialib/libs/ftp_client/clients/ftplib_client.py,sha256=VcpAn23r03iyCUAj35xHU_AVNrll_45uHFN8Z9OnBkE,2203
+saviialib/libs/ftp_client/ftp_client.py,sha256=Naj9p0yYWlXt9um0zKfvuHSoycM8JZg2SPBm8110pYk,1008
+saviialib/libs/ftp_client/ftp_client_contract.py,sha256=tymkugDzsJ5PzUXIaSkwX1h7T0naR15qAkjrqswqDyM,338
+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/log_client/__init__.py,sha256=2v6-pE7qwWLo7PjyysMLPKCDfpMOAtEqRGq_tw9Qlcs,333
+saviialib/libs/log_client/log_client.py,sha256=C_M-vlSQJmssIVNtco6KV9E2OXLdogP9ibDwuGJQw-I,1332
+saviialib/libs/log_client/log_client_contract.py,sha256=DmU-TLz4onH7LWM8tVu_HTp31Cx4WwOvPShF3rizoqE,524
+saviialib/libs/log_client/logging_client/logging_client.py,sha256=HkiKjEe_-mVfPmJYm3xI7ayKEa_4AiSXDJRqnyKijB0,1980
+saviialib/libs/log_client/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+saviialib/libs/log_client/types/log_client_types.py,sha256=fV8-uVbCOf4IqxR3IUKQiK_k5nbT_r3KWyuwhkBaSc4,1118
+saviialib/libs/log_client/utils/log_client_utils.py,sha256=NpFt_LvMvVSVswmoleMycjL6n1OlyfqDfWNs9SmKJfY,232
+saviialib/libs/sftp_client/__init__.py,sha256=f51sFOd_XIhhd6x6AZ3ZdbJ86hO1xnqAk9MmEjwRJ-c,229
+saviialib/libs/sftp_client/clients/asyncssh_sftp_client.py,sha256=vqCKHIx3K6QFujQP5DIAB5EYOz1zAdhi825LTRvhG20,3469
+saviialib/libs/sftp_client/sftp_client.py,sha256=_5HRYSBPadxZEdHuHSpQ_VrwerBfu24izNRg-pvLzlU,918
+saviialib/libs/sftp_client/sftp_client_contract.py,sha256=JWWxIfNBXcsBd8z3gQHGpeRASRjtP9WGkznoMfP0IZc,365
+saviialib/libs/sftp_client/types/sftp_client_types.py,sha256=NzUZVq6yeGKkO7KF-v4Cc-rwaWeOgFCUGVPL1YBbYgA,446
+saviialib/libs/sharepoint_client/__init__.py,sha256=6RbEzFtCfMrrY8F0JOCVcK6Gqt1FBJ09m0NuWHMCmCI,384
+saviialib/libs/sharepoint_client/clients/sharepoint_rest_api.py,sha256=I3OfZ5M4uR86hLIBOlOQzGNyTzQRy1yckrLF1ne7F1g,6319
+saviialib/libs/sharepoint_client/sharepoint_client.py,sha256=gXFisWWCk6pKhoEeaNN8dcHA5ywrGDLqfiKjchrHRy0,1816
+saviialib/libs/sharepoint_client/sharepoint_client_contract.py,sha256=H-WsXR5f50jy5RRYNlgV61y_YGjOUq4U_E1DWUUrDYw,612
+saviialib/libs/sharepoint_client/types/sharepoint_client_types.py,sha256=JruUCn6o16w00t4zxDrxmv_Bxa52UyShGYmwUFfBCCQ,482
+saviialib/libs/zero_dependency/utils/booleans_utils.py,sha256=Wc68B8TXMy_bCDRBlpbIimkcheyk-CBm8Ph6LyjV87c,83
+saviialib/libs/zero_dependency/utils/datetime_utils.py,sha256=c2H_JpUKpunCzDw6I4alDWNftEqaciWGtEUklPepm_s,759
+saviialib/libs/zero_dependency/utils/strings_utils.py,sha256=XqEukvCLkQ0PhjjPm9FTjrzbwBYMejs-0uSoLwSxhPo,133
+saviialib/services/backup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+saviialib/services/backup/api.py,sha256=S1dMGyyjYzVyo-E8FMttHZMOO2TtQoAMaLp-oquW46g,1408
+saviialib/services/backup/controllers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+saviialib/services/backup/controllers/types/__init__.py,sha256=0zIWXQb6YQVIIbb5b_FeL-D9Zy_d1GqR8kVz3hen4IU,222
+saviialib/services/backup/controllers/types/upload_backup_to_sharepoint_types.py,sha256=AzoHx3AWrVCM8LjmlEovDlRe4kJPJBbRoMToG8QK_Nw,464
+saviialib/services/backup/controllers/upload_backup_to_sharepoint.py,sha256=rW8FmcalRO1Ip8rhOsfpJIKRVYyn8oO-_jJSiS7MJOk,3827
+saviialib/services/backup/use_cases/constants/upload_backup_to_sharepoint_constants.py,sha256=erkn-3E8YwBMFs25o7exXoK7s73NdgP9IYDXeWzALcI,98
+saviialib/services/backup/use_cases/types/__init__.py,sha256=uVfu-L3-2QGnki0-rL2fOVTj4hVMvykyqKEv7kQHNvE,224
+saviialib/services/backup/use_cases/types/upload_backup_to_sharepoint_types.py,sha256=QSZ32Fsan-jGpmGFpip86N3S16oWaeIxri5at2x46nw,322
+saviialib/services/backup/use_cases/upload_backup_to_sharepoint.py,sha256=ZRzjwWncwgcB5_eNMsGBO37HVKMpkgWC0c_teaOrlos,18967
+saviialib/services/backup/utils/__init__.py,sha256=Khz07TAC17xGBbkSgNcOXSjzeFm6-NiQadNJ3R7tRgg,112
+saviialib/services/backup/utils/upload_backup_to_sharepoint_utils.py,sha256=oNZhzEkNooHGKs8eiPOmgh3I847favH1JjD3ROkSP2E,3258
+saviialib/services/netcamera/api.py,sha256=W8ZKfh_iGEvfE36yGXYH9RlveUUtHoxQI_E3__YGfq0,1182
+saviialib/services/netcamera/controllers/get_media_files.py,sha256=CEfZ7YRhXBcuGeK3HWB3Bpp-i-pIvAs70krreCHL_eA,1507
+saviialib/services/netcamera/controllers/types/get_media_files_types.py,sha256=40V0ARqtloRM16KYYxzeq5aQU-mrghEK7FfkeFoSmbk,417
+saviialib/services/netcamera/use_cases/get_media_files.py,sha256=ct_MOOgxzqCURQo2JJx1ioBaO-Qq-Gj-27Y4JAdZbeo,2801
+saviialib/services/netcamera/use_cases/types/get_media_files_types.py,sha256=XCpodI-WdZYbhd3DD1LkKDgLTSRKlXkHClbhwT8zXm8,333
+saviialib/services/shakes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+saviialib/services/shakes/api.py,sha256=WvmOJ35lPdJuqSEl9-q9VOGNxqkqvzfBUmkp-G8WKj4,1230
+saviialib/services/shakes/controllers/get_miniseed_files.py,sha256=k55QiIQoNHyMQsgW939IbrPY4tHy8cFMg51LDVQQSgs,1934
+saviialib/services/shakes/controllers/types/get_miniseed_files_types.py,sha256=LZ8LZxpjPYrl-EIuwQixXl8z4Ygl81DgodoHyxzvIxY,366
+saviialib/services/shakes/use_cases/get_miniseed_files.py,sha256=HD6VphToOF8eq-J281qOg9AgeD6hFAsVfScwvP5c9jc,3033
+saviialib/services/shakes/use_cases/types/get_miniseed_files_types.py,sha256=bb5XurP08pHhhNK80dvgoSP_OmHFEdKhT-jzyd8w5kk,385
+saviialib/services/shakes/use_cases/utils/get_miniseed_files_utils.py,sha256=6TEdu9MglnM0_FTuxs9BETneXqQBUGb-Q1rDKhvRLvg,288
+saviialib/services/thies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+saviialib/services/thies/api.py,sha256=jbKk1aMbGdQFEanQJnbouj7SCbwi2CtAwZVDeAXp26M,1646
+saviialib/services/thies/constants/update_thies_data_constants.py,sha256=3t5zthZOT3mPKqZZqCXhO13sIkiAbYeyyXz8ZRGXrPo,1592
+saviialib/services/thies/controllers/types/update_thies_data_types.py,sha256=95b7rq_VusvibsUKJj9EuKz1au0-n4ssew4LiBWWsB0,473
+saviialib/services/thies/controllers/update_thies_data.py,sha256=UVvLz-Py6m4FVAbi7ZWs2yL6n8rKSuQiWTXaWK5QGHc,4963
+saviialib/services/thies/use_cases/components/create_thies_statistics_file.py,sha256=uHz6XrRXUDrAbxpW1nnMaZ2Qu_Y3XTQblUAeZrgILM8,4531
+saviialib/services/thies/use_cases/components/thies_bp.py,sha256=1Iq5Wz3kqzJfQNawV_v8ORr_Pl-PoamFp_2Xo8DjvmI,15042
+saviialib/services/thies/use_cases/types/update_thies_data_types.py,sha256=oSisdBqCDU54QKbAE1IV4wjBjy02ynJdE4bbOLVgb0k,588
+saviialib/services/thies/use_cases/update_thies_data.py,sha256=MfAA6lRyyAdyQwc6yiKL2SdiPKXZNoKdxMtmj1vFdio,16750
+saviialib/services/thies/utils/update_thies_data_utils.py,sha256=EpjYWXqyHxJ-dO3MHhdXp-rGV7WyUckeFko-nnfnNac,555
+saviialib-1.6.1.dist-info/METADATA,sha256=I_HZJiOP8ELt1MZMyuwFqc9y7GpzRA_18p3GnJ-Bpjg,5235
+saviialib-1.6.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+saviialib-1.6.1.dist-info/licenses/LICENSE,sha256=NWpf6b38xgBWPBo5HZsCbdfp9hZSliEbRqWQgm0fkOo,1076
+saviialib-1.6.1.dist-info/RECORD,,

saviialib-1.6.1.dist-info/WHEEL

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

saviialib-1.6.1.dist-info/licenses/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.
+