saviialib 1.6.1__py3-none-any.whl

saviialib/libs/files_client/types/files_client_types.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from typing import Literal, Union, List, Dict
+
+
+@dataclass
+class FilesClientInitArgs:
+    client_name: str = "aiofiles_client"
+
+
+@dataclass
+class ReadArgs:
+    """
+    Represents the arguments required to read a file.
+
+    Attributes:
+        file_path (str): The path to the file to be read.
+        mode (Literal['r', 'rb']): The mode in which the file should be opened.
+            - 'r': Open for reading (text mode).
+            - 'rb': Open for reading (binary mode).
+    """
+
+    file_path: str
+    mode: Literal["r", "rb", "json"]
+    encoding: str = "utf-8"
+
+
+@dataclass
+class WriteArgs:
+    file_name: str
+    file_content: Union[str, bytes, List[Dict]]
+    mode: Literal["w", "wb", "a", "json"]
+    destination_path: str = ""

saviialib/libs/ftp_client/__init__.py

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

saviialib/libs/ftp_client/clients/aioftp_client.py

@@ -0,0 +1,52 @@
+from aioftp import Client
+from aioftp.errors import StatusCodeError
+from saviialib.libs.ftp_client.ftp_client_contract import (
+    FTPClientContract,
+)
+from saviialib.libs.ftp_client.types.ftp_client_types import (
+    FtpClientInitArgs,
+    FtpListFilesArgs,
+    FtpReadFileArgs,
+)
+
+
+class AioFTPClient(FTPClientContract):
+    def __init__(self, args: FtpClientInitArgs) -> None:
+        self.host = args.config.ftp_host
+        self.port = args.config.ftp_port
+        self.password = args.config.ftp_password
+        self.user = args.config.ftp_user
+        self.client = Client()
+
+    async def _async_start(self) -> None:
+        try:
+            await self.client.connect(host=self.host, port=self.port)
+        except OSError:
+            raise ConnectionRefusedError(
+                f"{self.host}:{self.port} isn't active. "
+                "Please ensure the server is running and accessible."
+            )
+        try:
+            await self.client.login(user=self.user, password=self.password)
+        except StatusCodeError:
+            raise ConnectionAbortedError(
+                "Authentication failed. Please verify your credentials and try again."
+            )
+
+    async def list_files(self, args: FtpListFilesArgs) -> list[str]:
+        try:
+            await self._async_start()
+            files = []
+            async for path, info in self.client.list(args.path, recursive=False):
+                files.append((path.name, int((info.get("size", 0)))))
+            return files
+        except StatusCodeError as error:
+            raise ConnectionAbortedError(error)
+
+    async def read_file(self, args: FtpReadFileArgs) -> bytes:
+        await self._async_start()
+        try:
+            async with self.client.download_stream(args.file_path) as stream:  # type: ignore
+                return await stream.read()
+        except StatusCodeError as error:
+            raise FileNotFoundError(f"File not found: {args.file_path}") from error

saviialib/libs/ftp_client/clients/ftplib_client.py

@@ -0,0 +1,58 @@
+import ftplib
+import asyncio
+from io import BytesIO
+from saviialib.libs.ftp_client.ftp_client_contract import (
+    FTPClientContract,
+)
+from saviialib.libs.ftp_client.types.ftp_client_types import (
+    FtpClientInitArgs,
+    FtpListFilesArgs,
+    FtpReadFileArgs,
+)
+
+
+class FtplibClient(FTPClientContract):
+    def __init__(self, args: FtpClientInitArgs) -> None:
+        self.host = args.config.ftp_host
+        self.port = args.config.ftp_port
+        self.password = args.config.ftp_password
+        self.user = args.config.ftp_user
+        self.client = ftplib.FTP(host=self.host, user=self.user, passwd=self.password)
+
+    async def _async_start(self) -> None:
+        try:
+            await asyncio.to_thread(self.client.login, self.user, self.password)
+        except OSError:
+            raise ConnectionRefusedError(
+                f"{self.host}:{self.port} isn't active. "
+                "Please ensure the server is running and accessible."
+            )
+        except Exception as error:
+            raise ConnectionError(
+                f"General connection for {self.host}:{self.port}.", error.__str__()
+            )
+
+    async def list_files(self, args: FtpListFilesArgs) -> list[str]:
+        try:
+            EXCLUDED_NAMES = [".", ".."]
+            await self._async_start()
+            await asyncio.to_thread(self.client.cwd, args.path)
+            filenames = await asyncio.to_thread(self.client.nlst, args.path)
+            return [
+                filename for filename in filenames if filename not in EXCLUDED_NAMES
+            ]
+        except Exception as error:
+            raise ConnectionAbortedError(error)
+
+    async def read_file(self, args: FtpReadFileArgs) -> bytes:
+        await self._async_start()
+        try:
+            file_content = BytesIO()
+            await asyncio.to_thread(
+                self.client.retrbinary, "RETR " + args.file_path, file_content.write
+            )
+            await asyncio.to_thread(file_content.seek, 0)
+            file_bytes = await asyncio.to_thread(file_content.read)
+            return file_bytes
+        except Exception as error:
+            raise FileNotFoundError(f"File not found: {args.file_path}") from error

saviialib/libs/ftp_client/ftp_client.py

@@ -0,0 +1,25 @@
+from .clients.aioftp_client import AioFTPClient
+from .clients.ftplib_client import FtplibClient
+from .ftp_client_contract import FTPClientContract
+from .types.ftp_client_types import FtpClientInitArgs, FtpListFilesArgs, FtpReadFileArgs
+
+
+class FTPClient(FTPClientContract):
+    CLIENTS = {"aioftp_client", "ftplib_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)
+        elif args.client_name == "ftplib_client":
+            self.client_obj = FtplibClient(args)
+        self.client_name = args.client_name
+
+    async def list_files(self, args: FtpListFilesArgs) -> list[str]:
+        return await self.client_obj.list_files(args)
+
+    async def read_file(self, args: FtpReadFileArgs) -> bytes:
+        return await self.client_obj.read_file(args)

saviialib/libs/ftp_client/ftp_client_contract.py

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

saviialib/libs/ftp_client/types/__init__.py

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

saviialib/libs/ftp_client/types/ftp_client_types.py

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

saviialib/libs/log_client/__init__.py

@@ -0,0 +1,19 @@
+from saviialib.libs.log_client.log_client import LogClient
+from .types.log_client_types import (
+    InfoArgs,
+    DebugArgs,
+    ErrorArgs,
+    WarningArgs,
+    LogClientArgs,
+    LogStatus,
+)
+
+__all__ = [
+    "LogClient",
+    "InfoArgs",
+    "DebugArgs",
+    "ErrorArgs",
+    "WarningArgs",
+    "LogClientArgs",
+    "LogStatus",
+]

saviialib/libs/log_client/log_client.py

@@ -0,0 +1,46 @@
+# Internal modules
+from saviialib.libs.log_client.log_client_contract import LogClientContract
+from saviialib.libs.log_client.logging_client.logging_client import LoggingClient
+from saviialib.libs.log_client.types.log_client_types import (
+    ErrorArgs,
+    InfoArgs,
+    LogClientArgs,
+    DebugArgs,
+    WarningArgs,
+)
+
+
+class LogClient(LogClientContract):
+    def __init__(self, args: LogClientArgs):
+        clients = {
+            "logging": LoggingClient(args),
+        }
+        if clients.get(args.client_name):
+            self.client_name = args.client_name
+            self.client_obj = clients[args.client_name]
+        else:
+            raise KeyError(f"Unsupported client '{args.client_name}'.")
+
+    @property
+    def method_name(self):
+        return self.client_obj.method_name
+
+    @method_name.setter
+    def method_name(self, method_name: str):
+        self.client_obj.method_name = method_name
+
+    @property
+    def log_history(self):
+        return self.client_obj.log_history
+
+    def info(self, args: InfoArgs):
+        return self.client_obj.info(args)
+
+    def error(self, args: ErrorArgs):
+        return self.client_obj.error(args)
+
+    def debug(self, args: DebugArgs):
+        return self.client_obj.debug(args)
+
+    def warning(self, args: WarningArgs):
+        return self.client_obj.warning(args)

saviialib/libs/log_client/log_client_contract.py

@@ -0,0 +1,28 @@
+# External libraries
+from abc import ABC, abstractmethod
+
+# Internal modules
+from saviialib.libs.log_client.types.log_client_types import (
+    ErrorArgs,
+    InfoArgs,
+    DebugArgs,
+    WarningArgs,
+)
+
+
+class LogClientContract(ABC):
+    @abstractmethod
+    def info(self, args: InfoArgs):
+        pass
+
+    @abstractmethod
+    def error(self, args: ErrorArgs):
+        pass
+
+    @abstractmethod
+    def debug(self, args: DebugArgs):
+        pass
+
+    @abstractmethod
+    def warning(self, args: WarningArgs):
+        pass

saviialib/libs/log_client/logging_client/logging_client.py

@@ -0,0 +1,58 @@
+# External libraries
+import logging
+
+# Internal modules
+from saviialib.libs.log_client.utils.log_client_utils import format_message
+from saviialib.libs.log_client.log_client_contract import LogClientContract
+from saviialib.libs.log_client.types.log_client_types import (
+    ErrorArgs,
+    InfoArgs,
+    LogClientArgs,
+    DebugArgs,
+    WarningArgs,
+)
+
+from saviialib.libs.zero_dependency.utils.datetime_utils import today, datetime_to_str
+
+
+class LoggingClient(LogClientContract):
+    def __init__(self, args: LogClientArgs):
+        log_format = "{message}"
+        logging.basicConfig(format=log_format, level=logging.INFO, style="{")
+        self.class_name = args.class_name
+        self.method_name = args.method_name
+        self.active_record = args.active_record
+        self.log_history = []
+
+    def _save_to_history(self, meta: dict):
+        self.log_history.append(
+            f"[{datetime_to_str(today(), date_format='%m-%d-%Y %H:%M:%S')}][{self.class_name}] {meta.get('msg', '')}"
+        )
+
+    def info(self, args: InfoArgs) -> None:
+        if self.active_record:
+            self._save_to_history(args.metadata)
+        return logging.info(
+            format_message(self.class_name, self.method_name, args.status)
+        )
+
+    def error(self, args: ErrorArgs) -> None:
+        if self.active_record:
+            self._save_to_history(args.metadata)
+        return logging.error(
+            format_message(self.class_name, self.method_name, args.status)
+        )
+
+    def debug(self, args: DebugArgs) -> None:
+        if self.active_record:
+            self._save_to_history(args.metadata)
+        return logging.debug(
+            format_message(self.class_name, self.method_name, args.status)
+        )
+
+    def warning(self, args: WarningArgs) -> None:
+        if self.active_record:
+            self._save_to_history(args.metadata)
+        return logging.warning(
+            format_message(self.class_name, self.method_name, args.status)
+        )

saviialib/libs/log_client/types/log_client_types.py

@@ -0,0 +1,47 @@
+from typing import Literal, Dict
+from enum import Enum
+from dataclasses import dataclass, field
+
+
+class LogStatus(Enum):
+    STARTED = "started"
+    SUCCESSFUL = "successful"
+    FAILED = "failed"
+    ERROR = "error"
+    EARLY_RETURN = "early_return"
+    ALERT = "alert"
+
+
+@dataclass
+class LogClientArgs:
+    client_name: str = field(default="logging")
+    service_name: str = field(default="")
+    class_name: str = field(default="")
+    method_name: str = field(default="")
+    active_record: bool = False
+
+
+@dataclass
+class InfoArgs:
+    status: Literal[LogStatus.STARTED, LogStatus.SUCCESSFUL, LogStatus.EARLY_RETURN]
+    metadata: Dict = field(default_factory=dict)
+
+
+@dataclass
+class DebugArgs:
+    status: Literal[
+        LogStatus.STARTED, LogStatus.SUCCESSFUL, LogStatus.EARLY_RETURN, LogStatus.ALERT
+    ]
+    metadata: Dict = field(default_factory=dict)
+
+
+@dataclass
+class ErrorArgs:
+    status: Literal[LogStatus.ERROR]
+    metadata: Dict = field(default_factory=dict)
+
+
+@dataclass
+class WarningArgs:
+    status: Literal[LogStatus.FAILED, LogStatus.ALERT]
+    metadata: Dict = field(default_factory=dict)

saviialib/libs/log_client/utils/log_client_utils.py

@@ -0,0 +1,6 @@
+# Internal libraries
+from saviialib.libs.log_client.types.log_client_types import LogStatus
+
+
+def format_message(class_name: str, method_name: str, status: LogStatus) -> str:
+    return f"{class_name}: {method_name}_{status.value}"

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/__init__.py

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