saviialib 0.9.1__py3-none-any.whl → 1.6.0__py3-none-any.whl

saviialib/libs/files_client/clients/aiofiles_client.py

@@ -1,21 +1,44 @@
 import aiofiles
-
+from saviialib.libs.directory_client.directory_client import (
+    DirectoryClient,
+    DirectoryClientArgs,
+)
 from saviialib.libs.files_client.files_client_contract import FilesClientContract
 from saviialib.libs.files_client.types.files_client_types import (
     FilesClientInitArgs,
     ReadArgs,
     WriteArgs,
 )
+import json
 
 
 class AioFilesClient(FilesClientContract):
     def __init__(self, args: FilesClientInitArgs):
-        pass
+        self.dir_client = DirectoryClient(DirectoryClientArgs(client_name="os_client"))
 
     async def read(self, args: ReadArgs) -> str | bytes:
+        if args.mode == "json":
+            async with aiofiles.open(
+                args.file_path, "r", encoding=args.encoding or "utf-8"
+            ) as file:
+                content = await file.read()
+                return json.loads(content)
+
         encoding = None if args.mode == "rb" else args.encoding
         async with aiofiles.open(args.file_path, args.mode, encoding=encoding) as file:
             return await file.read()
 
     async def write(self, args: WriteArgs) -> None:
-        return None
+        file_path = (
+            self.dir_client.join_paths(args.destination_path, args.file_name)
+            if args.destination_path
+            else args.file_name
+        )
+        if args.mode == "json":
+            async with aiofiles.open(file_path, "w", encoding="utf-8") as file:
+                json_str = json.dumps(args.file_content, ensure_ascii=False, indent=2)
+                await file.write(json_str)
+            return
+
+        async with aiofiles.open(file_path, args.mode) as file:
+            await file.write(args.file_content)

saviialib/libs/files_client/clients/csv_client.py

@@ -0,0 +1,42 @@
+import csv
+from asyncio import to_thread
+
+from saviialib.libs.directory_client.directory_client import (
+    DirectoryClient,
+    DirectoryClientArgs,
+)
+from saviialib.libs.files_client.files_client_contract import FilesClientContract
+from saviialib.libs.files_client.types.files_client_types import (
+    FilesClientInitArgs,
+    ReadArgs,
+    WriteArgs,
+)
+
+
+class CsvClient(FilesClientContract):
+    def __init__(self, args: FilesClientInitArgs):
+        self.dir_client = DirectoryClient(DirectoryClientArgs(client_name="os_client"))
+
+    async def read(self, args: ReadArgs) -> str | bytes:
+        raise OSError("This method is not implemented yet.")
+
+    async def write(self, args: WriteArgs) -> None:
+        file_type = args.file_name.split(".")[-1]
+        file_content = args.file_content
+        header = file_content[0].keys()
+        if file_type == "tsv":
+            delimiter = "\t"
+        else:  # Default CSV.
+            delimiter = ","
+
+        if args.destination_path == "":
+            dest_path = self.dir_client.join_paths(args.file_name)
+        else:
+            dest_path = self.dir_client.join_paths(
+                args.destination_path, args.file_name
+            )
+
+        with open(dest_path, "w", newline="") as file:
+            writer = csv.DictWriter(file, fieldnames=header, delimiter=delimiter)  # type: ignore
+            await to_thread(writer.writeheader)
+            await to_thread(writer.writerows, file_content)  # type: ignore

saviialib/libs/files_client/files_client.py

@@ -1,10 +1,11 @@
 from .clients.aiofiles_client import AioFilesClient
+from .clients.csv_client import CsvClient
 from .files_client_contract import FilesClientContract
 from .types.files_client_types import FilesClientInitArgs, ReadArgs, WriteArgs
 
 
 class FilesClient(FilesClientContract):
-    CLIENTS = {"aiofiles_client"}
+    CLIENTS = {"aiofiles_client", "csv_client"}
 
     def __init__(self, args: FilesClientInitArgs) -> None:
         if args.client_name not in FilesClient.CLIENTS:
@@ -13,15 +14,12 @@ class FilesClient(FilesClientContract):
 
         if args.client_name == "aiofiles_client":
             self.client_obj = AioFilesClient(args)
+        elif args.client_name == "csv_client":
+            self.client_obj = CsvClient(args)
+
         self.client_name = args.client_name
 
     async def read(self, args: ReadArgs):
-        """Reads data from a specified source using the provided arguments.
-
-        :param args (ReadArgs): An object containing the parameters required for the read operation.
-
-        :return file: The result of the read operation, as returned by the client object.
-        """
         return await self.client_obj.read(args)
 
     async def write(self, args: WriteArgs):

saviialib/libs/files_client/types/files_client_types.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Literal
+from typing import Literal, Union, List, Dict
 
 
 @dataclass
@@ -20,12 +20,13 @@ class ReadArgs:
     """
 
     file_path: str
-    mode: Literal["r", "rb"]
+    mode: Literal["r", "rb", "json"]
     encoding: str = "utf-8"
 
 
 @dataclass
 class WriteArgs:
-    destination_path: str
     file_name: str
-    file_content: str | bytes
+    file_content: Union[str, bytes, List[Dict]]
+    mode: Literal["w", "wb", "a", "json"]
+    destination_path: str = ""

saviialib/libs/ftp_client/clients/aioftp_client.py

@@ -34,12 +34,19 @@ class AioFTPClient(FTPClientContract):
             )
 
     async def list_files(self, args: FtpListFilesArgs) -> list[str]:
-        await self._async_start()
-        return [
-            path.name async for path, _ in self.client.list(args.path, recursive=False)
-        ]
+        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()
-        async with self.client.download_stream(args.file_path) as stream:
-            return await stream.read()
+        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

@@ -1,10 +1,11 @@
 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"}
+    CLIENTS = {"aioftp_client", "ftplib_client"}
 
     def __init__(self, args: FtpClientInitArgs) -> None:
         if args.client_name not in FTPClient.CLIENTS:
@@ -13,10 +14,12 @@ class FTPClient(FTPClientContract):
 
         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
 
-    def list_files(self, args: FtpListFilesArgs) -> list[str]:
-        return self.client_obj.list_files(args)
+    async def list_files(self, args: FtpListFilesArgs) -> list[str]:
+        return await self.client_obj.list_files(args)
 
-    def read_file(self, args: FtpReadFileArgs) -> bytes:
-        return self.client_obj.read_file(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

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

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

@@ -4,6 +4,7 @@ from .types.sharepoint_client_types import (
     SpListFilesArgs,
     SpListFoldersArgs,
     SpUploadFileArgs,
+    SpCreateFolderArgs,
 )
 
 __all__ = [
@@ -12,4 +13,5 @@ __all__ = [
     "SpListFilesArgs",
     "SpListFoldersArgs",
     "SpUploadFileArgs",
+    "SpCreateFolderArgs",
 ]