saviialib 1.4.0__tar.gz → 1.5.0__tar.gz

saviialib-1.5.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: saviialib
+Version: 1.5.0
+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.5.0/README.md

@@ -0,0 +1,98 @@
+# 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.4.0 → saviialib-1.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "saviialib"
-version = "1.4.0"
+version = "1.5.0"
 description = "A client library for IoT projects in the RCER initiative"
 authors = ["pedropablozavalat"]
 license = "MIT"
@@ -17,6 +17,8 @@ numpy = ">=2.2.0,<2.4.0"
 pandas = ">=2.2.3,<2.3.1"
 bitarray="*"
 certifi="*"
+ffmpeg-asyncio="0.1.3"
+asyncssh="2.21.1"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "8.3.5"

{saviialib-1.4.0 → saviialib-1.5.0}/src/saviialib/__init__.py

@@ -12,6 +12,8 @@ from saviialib.services.thies.api import SaviiaThiesAPI
 from saviialib.general_types.api.saviia_thies_api_types import SaviiaThiesConfig
 from saviialib.general_types.api.saviia_backup_api_types import SaviiaBackupConfig
 
+__all__ = ["SaviiaAPI", "SaviiaAPIConfig"]
+
 
 class SaviiaAPI:
     API_REGISTRY: Dict[str, Type] = {

{saviialib-1.4.0 → saviialib-1.5.0}/src/saviialib/general_types/api/saviia_api_types.py

@@ -30,6 +30,7 @@ class SaviiaAPIConfig:
     sharepoint_site_name: str
     logger: Logger
 
+
 @dataclass
 class FtpClientConfig:
     ftp_host: str

saviialib-1.5.0/src/saviialib/general_types/api/saviia_netcamera_api_types.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+from logging import Logger
+
+
+@dataclass
+class SaviiaNetcameraConfig:
+    username: str
+    password: str
+    protocol: str
+    logger: Logger
+    destination_path: str = "/"

saviialib-1.5.0/src/saviialib/general_types/api/saviia_shakes_api_types.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from logging import Logger
+
+
+@dataclass
+class SaviiaShakesConfig:
+    """
+    Configuration for Raspberry shakes activities as Miniseed extraction, photo record and video record.
+
+    Attributes:
+        sftp_user (str): Username for SFTP Client connection
+        sftp_password (str): Password for SFTP Client connection
+        sftp_port (str): SFTP Server Port. Default port is 22.
+        ssh_key_path (str): Path to the SSH Private key for client-side authentication.
+    """
+
+    sftp_user: str
+    sftp_password: str
+    ssh_key_path: str
+    logger: Logger
+    sftp_port: int = 22

{saviialib-1.4.0 → saviialib-1.5.0}/src/saviialib/general_types/error_types/api/saviia_api_error_types.py

@@ -103,3 +103,11 @@ class BackupEmptyError(Exception):
 
     def __str__(self):
         return "The local backup folder is empty. "
+
+
+class ShakesNoContentError(Exception):
+    def __init__(self, *args):
+        super().__init__(*args)
+
+    def __str__(self):
+        return "All the miniSEED files have been downloaded and are in the local directory."

saviialib-1.5.0/src/saviialib/general_types/error_types/api/saviia_netcamera_error_types.py

@@ -0,0 +1,7 @@
+class NetcameraConnectionError(Exception):
+    def __init__(self, *args, reason):
+        super().__init__(*args, reason)
+        self.reason = reason
+
+    def __str__(self):
+        return "Netcamera Connection failed. " + self.reason.__str__()

{saviialib-1.4.0 → saviialib-1.5.0}/src/saviialib/general_types/error_types/common/common_types.py

@@ -15,3 +15,12 @@ class SharepointClientError(Exception):
 class FtpClientError(Exception):
     def __str__(self):
         return "Ftp Client initialization fails."
+
+
+class SftpClientError(Exception):
+    def __init__(self, *args, reason):
+        super().__init__(*args, reason)
+        self.reason = reason
+
+    def __str__(self):
+        return "SFTP Client initialization fails." + self.reason.__str__()

{saviialib-1.4.0 → saviialib-1.5.0}/src/saviialib/libs/directory_client/client/os_client.py

@@ -19,7 +19,7 @@ class OsClient(DirectoryClientContract):
         return await asyncio.to_thread(os.listdir, path)
 
     @staticmethod
-    async def isdir(path: str) -> list:
+    async def isdir(path: str) -> bool:
         return await asyncio.to_thread(os.path.isdir, path)
 
     @staticmethod

saviialib-1.5.0/src/saviialib/libs/ffmpeg_client/__init__.py

@@ -0,0 +1,8 @@
+from .ffmpeg_client import (
+    FfmpegClient,
+    FfmpegClientInitArgs,
+    RecordPhotoArgs,
+    RecordVideoArgs,
+)
+
+__all__ = ["FfmpegClient", "FfmpegClientInitArgs", "RecordPhotoArgs", "RecordVideoArgs"]

saviialib-1.5.0/src/saviialib/libs/ffmpeg_client/clients/ffmpeg_asyncio_client.py

@@ -0,0 +1,101 @@
+from saviialib.libs.ffmpeg_client.types.ffmpeg_client_types import (
+    FfmpegClientInitArgs,
+    RecordPhotoArgs,
+    RecordVideoArgs,
+)
+from saviialib.libs.ffmpeg_client.ffmpeg_client_contract import FfmpegClientContract
+from typing import List
+import asyncio
+import shutil
+
+from saviialib.libs.directory_client import DirectoryClient, DirectoryClientArgs
+from saviialib.libs.zero_dependency.utils.datetime_utils import today, datetime_to_str
+
+
+class FfmpegAsyncioClient(FfmpegClientContract):
+    def __init__(self, args: FfmpegClientInitArgs) -> None:
+        self.dir_client = DirectoryClient(DirectoryClientArgs("os_client"))
+
+    def _setup_io_args(
+        self,
+        rtsp_user: str,
+        rtsp_pwd: str,
+        ip: str,
+        dest_path: str,
+        record_prefix: str,
+        record_type: str,
+    ):
+        input_arg = f"rtsp://{rtsp_user}:{rtsp_pwd}@{ip}/stream1"
+        output_file = (
+            record_prefix
+            + "_"
+            + datetime_to_str(today(), date_format="%m-%d-%Y_%H-%M-%S")
+            + f".{record_type}"
+        )
+        output_arg = self.dir_client.join_paths(dest_path, output_file)
+        return input_arg, output_arg
+
+    async def _ensure_ffmpeg_available(self):
+        if shutil.which("ffmpeg"):
+            return
+        install_cmd = ["apk", "add", "ffmpeg"]  # Only for Home Assistant OS
+        process = await asyncio.create_subprocess_shell(
+            *install_cmd,
+            stdout=asyncio.subprocess.DEVNULL,
+            stdin=asyncio.subprocess.PIPE,
+        )
+        _, stderr = await process.communicate()
+        if process.returncode != 0:
+            raise ConnectionAbortedError("Failed to install ffmpeg: ", stderr.decode())
+
+    async def _setup_command(
+        self, input_arg: str, output_arg: str, extra: dict
+    ) -> List[str]:
+        await self._ensure_ffmpeg_available()  # Validate ffmpeg module is installed.
+        cmd = ["ffmpeg", "-y", "-i", input_arg, output_arg]
+        for k, v in extra.values():
+            cmd.insert(-1, k)
+            cmd.insert(-1, v)
+        return list(map(str, cmd))
+
+    async def record_video(self, args: RecordVideoArgs):
+        input_arg, output_arg = self._setup_io_args(
+            args.rtsp_user,
+            args.rtsp_password,
+            args.ip_address,
+            args.destination_path,
+            "Video",
+            args.extension,
+        )
+        cmd = await self._setup_command(
+            input_arg, output_arg, extra={"-t": args.duration}
+        )
+        process = await asyncio.create_subprocess_exec(
+            *cmd, stderr=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE
+        )
+        _, stderr = await process.communicate()
+        if process.returncode != 0:
+            raise ConnectionError(
+                "Unexpected error while recording the video: ", stderr.decode()
+            )
+
+    async def record_photo(self, args: RecordPhotoArgs):
+        input_arg, output_arg = self._setup_io_args(
+            args.rtsp_user,
+            args.rtsp_password,
+            args.ip_address,
+            args.destination_path,
+            "Photo",
+            args.extension,
+        )
+        cmd = await self._setup_command(
+            input_arg, output_arg, extra={"-frames:v": args.frames}
+        )
+        process = await asyncio.create_subprocess_exec(
+            *cmd, stderr=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE
+        )
+        _, stderr = await process.communicate()
+        if process.returncode != 0:
+            raise ConnectionError(
+                "Unexpected error while recording the photo: ", stderr.decode()
+            )

saviialib-1.5.0/src/saviialib/libs/ffmpeg_client/ffmpeg_client.py

@@ -0,0 +1,25 @@
+from .ffmpeg_client_contract import FfmpegClientContract
+from .types.ffmpeg_client_types import (
+    RecordPhotoArgs,
+    RecordVideoArgs,
+    FfmpegClientInitArgs,
+)
+from .clients.ffmpeg_asyncio_client import FfmpegAsyncioClient
+
+
+class FfmpegClient(FfmpegClientContract):
+    CLIENTS = {"ffmpeg_asyncio"}
+
+    def __init__(self, args: FfmpegClientInitArgs) -> None:
+        if args.client_name not in FfmpegClient.CLIENTS:
+            msg = f"Unsupported client {args.client_name}"
+            raise KeyError(msg)
+        if args.client_name == "ffmpeg_asyncio":
+            self.client_obj = FfmpegAsyncioClient(args)
+        self.client_name = args.client_name
+
+    def record_photo(self, args: RecordPhotoArgs):
+        return self.client_obj.record_photo(args)
+
+    def record_video(self, args: RecordVideoArgs):
+        return self.client_obj.record_video(args)

saviialib-1.5.0/src/saviialib/libs/ffmpeg_client/ffmpeg_client_contract.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+from .types.ffmpeg_client_types import RecordPhotoArgs, RecordVideoArgs
+
+
+class FfmpegClientContract(ABC):
+    @abstractmethod
+    async def record_photo(self, args: RecordPhotoArgs):
+        pass
+
+    @abstractmethod
+    async def record_video(self, args: RecordVideoArgs):
+        pass

saviialib-1.5.0/src/saviialib/libs/ffmpeg_client/types/ffmpeg_client_types.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class FfmpegClientInitArgs:
+    client_name: str
+
+
+@dataclass
+class RecordPhotoArgs:
+    ip_address: str
+    destination_path: str
+    rtsp_user: str
+    rtsp_password: str
+    port: str
+    extension: str
+    frames: int
+
+
+@dataclass
+class RecordVideoArgs:
+    destination_path: str
+    ip_address: str
+    port: str
+    rtsp_user: str
+    rtsp_password: str
+    extension: str
+    duration: int

saviialib-1.5.0/src/saviialib/libs/sftp_client/__init__.py

@@ -0,0 +1,8 @@
+from .sftp_client import SFTPClient
+from .types.sftp_client_types import (
+    ListfilesArgs,
+    DownloadfilesArgs,
+    SFTPClientInitArgs,
+)
+
+__all__ = ["SFTPClient", "ListfilesArgs", "DownloadfilesArgs", "SFTPClientInitArgs"]

saviialib-1.5.0/src/saviialib/libs/sftp_client/clients/asyncssh_sftp_client.py

@@ -0,0 +1,83 @@
+from saviialib.libs.sftp_client.sftp_client_contract import SFTPClientContract
+from saviialib.libs.sftp_client.types.sftp_client_types import (
+    SFTPClientInitArgs,
+    ListfilesArgs,
+    DownloadfilesArgs,
+)
+from typing import Optional, List, Tuple
+from saviialib.general_types.error_types.common.common_types import EmptyDataError
+import asyncssh  # type: ignore
+from saviialib.libs.directory_client import DirectoryClient, DirectoryClientArgs
+
+
+class AsyncsshSFTPClient(SFTPClientContract):
+    def __init__(self, args: SFTPClientInitArgs) -> None:
+        self.host: str = args.host
+        self.port: int = args.port
+        self.username: str = args.username
+        self.password: Optional[str] = args.password
+        self.ssh_key_path: Optional[str] = args.ssh_key_path
+        self.dir_client = DirectoryClient(DirectoryClientArgs("os_client"))
+        self._validate_credentials()
+
+    def _validate_credentials(self):
+        if not self.password and not self.ssh_key_path:
+            raise EmptyDataError(
+                reason="At least one attribute (ssh key or password) must be provided"
+            )
+
+    async def _start_connection(
+        self,
+    ) -> Tuple[asyncssh.SSHClientConnection, asyncssh.SFTPClient]:
+        try:
+            ssh_connection = await asyncssh.connect(
+                self.host,
+                username=self.username,
+                port=self.port,
+                client_keys=[self.ssh_key_path],
+                password=self.password,
+            )
+            sftp_client = await ssh_connection.start_sftp_client()
+            return ssh_connection, sftp_client
+        except (OSError, asyncssh.Error) as exc:
+            raise ConnectionError("SFTP Operation failed: " + str(exc))
+
+    async def list_files(self, args: ListfilesArgs) -> List[str]:
+        ssh_conn, sftp_client = await self._start_connection()
+        async with ssh_conn:
+            async with sftp_client:
+                files = await sftp_client.listdir(args.path)
+                files = [f for f in files if f not in (".", "..")]
+                return files
+        await self._end_connection(ssh_conn)
+
+    async def download_files(self, args: DownloadfilesArgs) -> None:
+        ssh_conn, sftp_client = await self._start_connection()
+        if not args.destination_path or not args.source_path:
+            conflict_path = (
+                "destination path" if not args.destination_path else "source path"
+            )
+            raise ConnectionError(f"The {conflict_path} must be provided.")
+
+        download_all = len(args.files_to_download) == 0
+        async with ssh_conn:
+            async with sftp_client:
+                if download_all:
+                    await sftp_client.get(
+                        args.source_path,
+                        args.destination_path,
+                        recurse=True,
+                        preserve=True,
+                    )
+                else:
+                    for filename in args.files_to_download:
+                        source_path = self.dir_client.join_paths(
+                            args.source_path, filename
+                        )
+                        dest_path = self.dir_client.join_paths(
+                            args.destination_path, filename
+                        )
+                        await sftp_client.get(source_path, dest_path)
+
+    async def _end_connection(self, connection) -> None:
+        await connection.wait_closed()

saviialib-1.5.0/src/saviialib/libs/sftp_client/sftp_client.py

@@ -0,0 +1,26 @@
+from .sftp_client_contract import SFTPClientContract
+from .types.sftp_client_types import (
+    SFTPClientInitArgs,
+    ListfilesArgs,
+    DownloadfilesArgs,
+)
+from .clients.asyncssh_sftp_client import AsyncsshSFTPClient
+from typing import List
+
+
+class SFTPClient(SFTPClientContract):
+    CLIENTS = {"asyncssh_sftp"}
+
+    def __init__(self, args: SFTPClientInitArgs) -> None:
+        if args.client_name not in SFTPClient.CLIENTS:
+            msg = f"Unsupported client {args.client_name}"
+            raise KeyError(msg)
+        if args.client_name == "asyncssh_sftp":
+            self.client_obj = AsyncsshSFTPClient(args)
+        self.client_name = args.client_name
+
+    async def list_files(self, args: ListfilesArgs) -> List[str]:
+        return await self.client_obj.list_files(args)
+
+    async def download_files(self, args: DownloadfilesArgs) -> None:
+        return await self.client_obj.download_files(args)

saviialib-1.5.0/src/saviialib/libs/sftp_client/sftp_client_contract.py

@@ -0,0 +1,13 @@
+from .types.sftp_client_types import ListfilesArgs, DownloadfilesArgs
+from abc import ABC, abstractmethod
+from typing import List
+
+
+class SFTPClientContract(ABC):
+    @abstractmethod
+    async def list_files(self, args: ListfilesArgs) -> List[str]:
+        pass
+
+    @abstractmethod
+    async def download_files(self, args: DownloadfilesArgs) -> None:
+        pass