saviialib 1.3.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

saviialib/__init__.py

@@ -3,7 +3,77 @@ from importlib.metadata import version
 
 __version__ = version("saviialib")
 
-from .services.epii.api import EpiiAPI
-from .general_types.api.epii_api_types import EpiiAPIConfig
+from .general_types.api.saviia_api_types import SaviiaAPIConfig
 
-__all__ = ["EpiiAPI", "EpiiAPIConfig"]
+from typing import Dict, Type, Any, overload, Literal, List
+
+from saviialib.services.backup.api import SaviiaBackupAPI
+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] = {
+        "thies": SaviiaThiesAPI,
+        "backup": SaviiaBackupAPI,
+    }
+
+    @overload
+    def get(self, name: Literal["thies"]) -> SaviiaThiesAPI: ...
+    @overload
+    def get(self, name: Literal["backup"]) -> SaviiaBackupAPI: ...
+
+    def __init__(self, config: SaviiaAPIConfig):
+        """
+        Receive a dictionary of configurations, with the same key
+        as those registered in API_REGISTRY.
+
+        :params configs: Dictionary of configurations for each API.
+
+        Example:
+            configs = {
+                "thies": SaviiaThiesConfig(...),
+                "backup": SaviiaBackupConfig(...)
+            }
+        """
+        self._instances: Dict[str, Any] = {}
+
+        for name, api_class in SaviiaAPI.API_REGISTRY.items():
+            if name == "thies":
+                service_config = SaviiaThiesConfig(
+                    ftp_host=config.ftp_host,
+                    ftp_port=config.ftp_port,
+                    ftp_user=config.ftp_user,
+                    ftp_password=config.ftp_password,
+                    sharepoint_client_id=config.sharepoint_client_id,
+                    sharepoint_client_secret=config.sharepoint_client_secret,
+                    sharepoint_tenant_id=config.sharepoint_tenant_id,
+                    sharepoint_tenant_name=config.sharepoint_tenant_name,
+                    sharepoint_site_name=config.sharepoint_site_name,
+                    logger=config.logger,
+                )
+            elif name == "backup":
+                service_config = SaviiaBackupConfig(
+                    sharepoint_client_id=config.sharepoint_client_id,
+                    sharepoint_client_secret=config.sharepoint_client_secret,
+                    sharepoint_tenant_id=config.sharepoint_tenant_id,
+                    sharepoint_tenant_name=config.sharepoint_tenant_name,
+                    sharepoint_site_name=config.sharepoint_site_name,
+                    logger=config.logger,
+                )
+
+            self._instances[name] = api_class(service_config)
+
+    def get(self, name: Literal["thies", "backup"]) -> Any:
+        """Returns the API instance associated with the given name."""
+        try:
+            return self._instances[name]
+        except KeyError:
+            raise ValueError(f"API '{name}' is not registered or not configured.")
+
+    def list_available(self) -> List[str]:
+        """List of available registered APIs."""
+        return list(self._instances.keys())

saviialib/general_types/api/__init__.py

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

saviialib/general_types/api/{epii_api_types.py → saviia_api_types.py}

@@ -3,9 +3,9 @@ from logging import Logger
 
 
 @dataclass
-class EpiiAPIConfig:
+class SaviiaAPIConfig:
     """
-    Configuration for Epii API.
+    Configuration for SAVIIA API.
 
     Attributes:
         ftp_port (int): Port number of the FTP server.
@@ -46,39 +46,3 @@ class SharepointConfig:
     sharepoint_tenant_id: str
     sharepoint_tenant_name: str
     sharepoint_site_name: str
-
-
-@dataclass
-class EpiiUpdateThiesConfig:
-    ftp_port: int
-    ftp_host: str
-    ftp_user: str
-    ftp_password: str
-    sharepoint_client_id: str
-    sharepoint_client_secret: str
-    sharepoint_tenant_id: str
-    sharepoint_tenant_name: str
-    sharepoint_site_name: str
-    logger: Logger
-
-
-@dataclass
-class EpiiSharepointBackupConfig:
-    """
-    Configuration for backing up files to SharePoint.
-
-    Attributes:
-        sharepoint_client_id (str): Client ID for SharePoint authentication.
-        sharepoint_client_secret (str): Client secret for SharePoint authentication.
-        sharepoint_tenant_id (str): Tenant ID for SharePoint authentication.
-        sharepoint_tenant_name (str): Tenant name for SharePoint.
-        sharepoint_site_name (str): Site name in SharePoint.
-        local_backup_source_path (str): Local path to backup.
-    """
-
-    sharepoint_client_id: str
-    sharepoint_client_secret: str
-    sharepoint_tenant_id: str
-    sharepoint_tenant_name: str
-    sharepoint_site_name: str
-    logger: Logger

saviialib/general_types/api/saviia_backup_api_types.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+from logging import Logger
+
+
+@dataclass
+class SaviiaBackupConfig:
+    """
+    Configuration for backing up files to SharePoint.
+
+    Attributes:
+        sharepoint_client_id (str): Client ID for SharePoint authentication.
+        sharepoint_client_secret (str): Client secret for SharePoint authentication.
+        sharepoint_tenant_id (str): Tenant ID for SharePoint authentication.
+        sharepoint_tenant_name (str): Tenant name for SharePoint.
+        sharepoint_site_name (str): Site name in SharePoint.
+        local_backup_source_path (str): Local path to backup.
+    """
+
+    sharepoint_client_id: str
+    sharepoint_client_secret: str
+    sharepoint_tenant_id: str
+    sharepoint_tenant_name: str
+    sharepoint_site_name: str
+    logger: Logger

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/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/general_types/api/saviia_thies_api_types.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+from logging import Logger
+
+
+@dataclass
+class SaviiaThiesConfig:
+    """
+    Configuration for Saviia Thies.
+
+    Attributes:
+        ftp_port (int): Port number of the FTP server.
+        ftp_host (str): Hostname or IP address of the FTP server.
+        ftp_user (str): Username for the FTP server.
+        ftp_password (str): Password for the FTP server.
+        sharepoint_client_id (str): Client ID for SharePoint authentication.
+        sharepoint_client_secret (str): Client secret for SharePoint authentication.
+        sharepoint_tenant_id (str): Tenant ID for SharePoint authentication.
+        sharepoint_tenant_name (str): Tenant name for SharePoint.
+        sharepoint_site_name (str): Site name in SharePoint.
+    """
+
+    ftp_host: str
+    ftp_port: int
+    ftp_user: str
+    ftp_password: str
+    sharepoint_client_id: str
+    sharepoint_client_secret: str
+    sharepoint_tenant_id: str
+    sharepoint_tenant_name: str
+    sharepoint_site_name: str
+    logger: Logger

saviialib/general_types/error_types/api/{epii_api_error_types.py → 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/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/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/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/libs/ffmpeg_client/__init__.py

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

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/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/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/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/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/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/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/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

saviialib/libs/sftp_client/types/sftp_client_types.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass, field
+from typing import Optional, List
+
+
+@dataclass
+class SFTPClientInitArgs:
+    client_name: str
+    password: Optional[str]
+    username: str
+    ssh_key_path: str
+    host: str = "localhost"
+    port: int = 22
+
+
+@dataclass
+class ListfilesArgs:
+    path: str
+
+
+@dataclass
+class DownloadfilesArgs:
+    source_path: str
+    destination_path: str
+    files_to_download: List[str] = field(default_factory=list)

saviialib/libs/sharepoint_client/clients/sharepoint_rest_api.py

@@ -1,7 +1,9 @@
 from typing import Any
 import json
-from aiohttp import ClientError, ClientSession
+from aiohttp import ClientError, ClientSession, TCPConnector
 from dotenv import load_dotenv
+import ssl
+import certifi
 
 from saviialib.libs.sharepoint_client.sharepoint_client_contract import (
     SharepointClientContract,
@@ -15,6 +17,7 @@ from saviialib.libs.sharepoint_client.types.sharepoint_client_types import (
 )
 
 load_dotenv()
+ssl_context = ssl.create_default_context(cafile=certifi.where())
 
 
 class SharepointRestAPI(SharepointClientContract):
@@ -51,7 +54,7 @@ class SharepointRestAPI(SharepointClientContract):
             "Content-Type": "application/x-www-form-urlencoded",
         }
 
-        async with ClientSession() as session:
+        async with ClientSession(connector=TCPConnector(ssl=ssl_context)) as session:
             # Load access token
             response = await session.post(url, data=payload, headers=headers)
             if response.status != 200:
@@ -75,8 +78,9 @@ class SharepointRestAPI(SharepointClientContract):
                 "Content-Type": "application/json",
             }
             self.base_url = f"{site_url}/sites/{self.site_name}/_api/"
+            connector = TCPConnector(ssl=ssl_context)
             self.session = ClientSession(
-                headers=self.base_headers, base_url=self.base_url
+                headers=self.base_headers, base_url=self.base_url, connector=connector
             )
             return self
         except ClientError as error:

saviialib/libs/zero_dependency/utils/strings_utils.py

@@ -0,0 +1,5 @@
+def are_equal(str1: str, str2: str) -> bool:
+    if str1.lower() == str2.lower():
+        return True
+    else:
+        return False