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

saviialib/services/backup/api.py

@@ -0,0 +1,36 @@
+from typing import Any, Dict
+
+from .controllers.upload_backup_to_sharepoint import (
+    UploadBackupToSharepointControllerInput,
+)
+from .controllers.upload_backup_to_sharepoint import UploadBackupToSharepointController
+from saviialib.general_types.api.saviia_backup_api_types import SaviiaBackupConfig
+
+
+class SaviiaBackupAPI:
+    """
+    EpiiAPI is a service class that provides methods to interact with Patagonia Center system.
+    """
+
+    def __init__(self, config: SaviiaBackupConfig):
+        self.config = config
+
+    async def upload_backup_to_sharepoint(
+        self, local_backup_source_path: str, sharepoint_destination_path: str
+    ) -> Dict[str, Any]:
+        """Migrate a backup folder from Home assistant to Sharepoint directory.
+        Args:
+            local_backup_source_path (str): Local path to backup.
+        Returns:
+            response (dict): A dictionary containing the response from the upload operation.
+                This dictionary will typically include information about the success or
+                failure of the upload, as well as any relevant metadata.
+        """
+
+        controller = UploadBackupToSharepointController(
+            UploadBackupToSharepointControllerInput(
+                self.config, local_backup_source_path, sharepoint_destination_path
+            )
+        )
+        response = await controller.execute()
+        return response.__dict__

saviialib/services/{epii → backup}/controllers/types/__init__.py

@@ -1,4 +1,4 @@
-from .update_thies_data_types import (
+from ....thies.controllers.types.update_thies_data_types import (
     UpdateThiesDataControllerInput,
     UpdateThiesDataControllerOutput,
 )

saviialib/services/{epii → backup}/controllers/types/upload_backup_to_sharepoint_types.py

@@ -1,12 +1,12 @@
 from dataclasses import dataclass, field
 from typing import Dict
 
-from saviialib.general_types.api.epii_api_types import EpiiSharepointBackupConfig
+from saviialib.general_types.api.saviia_backup_api_types import SaviiaBackupConfig
 
 
 @dataclass
 class UploadBackupToSharepointControllerInput:
-    config: EpiiSharepointBackupConfig
+    config: SaviiaBackupConfig
     local_backup_source_path: str
     sharepoint_destination_path: str
 

saviialib/services/{epii → backup}/controllers/upload_backup_to_sharepoint.py

@@ -1,7 +1,7 @@
 from http import HTTPStatus
-from saviialib.general_types.api.epii_api_types import SharepointConfig
+from saviialib.general_types.api.saviia_api_types import SharepointConfig
 
-from saviialib.general_types.error_types.api.epii_api_error_types import (
+from saviialib.general_types.error_types.api.saviia_api_error_types import (
     BackupUploadError,
     BackupSourcePathError,
     BackupEmptyError,
@@ -10,14 +10,14 @@ from saviialib.general_types.error_types.common.common_types import (
     EmptyDataError,
     SharepointClientError,
 )
-from saviialib.services.epii.controllers.types.upload_backup_to_sharepoint_types import (
+from saviialib.services.backup.controllers.types.upload_backup_to_sharepoint_types import (
     UploadBackupToSharepointControllerInput,
     UploadBackupToSharepointControllerOutput,
 )
-from saviialib.services.epii.use_cases.types.upload_backup_to_sharepoint_types import (
+from saviialib.services.backup.use_cases.types.upload_backup_to_sharepoint_types import (
     UploadBackupToSharepointUseCaseInput,
 )
-from saviialib.services.epii.use_cases.upload_backup_to_sharepoint import (
+from saviialib.services.backup.use_cases.upload_backup_to_sharepoint import (
     UploadBackupToSharepointUsecase,
 )
 

saviialib/services/{epii → backup}/use_cases/types/__init__.py

@@ -1,4 +1,4 @@
-from .update_thies_data_types import (
+from ....thies.use_cases.types.update_thies_data_types import (
     FtpClientConfig,
     SharepointConfig,
     UpdateThiesDataUseCaseInput,

saviialib/services/{epii → backup}/use_cases/types/upload_backup_to_sharepoint_types.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from saviialib.general_types.api.epii_api_types import SharepointConfig
+from saviialib.general_types.api.saviia_api_types import SharepointConfig
 from logging import Logger
 
 

saviialib/services/{epii → backup}/use_cases/upload_backup_to_sharepoint.py

@@ -2,7 +2,7 @@ import asyncio
 from time import time
 from saviialib.libs.zero_dependency.utils.datetime_utils import today, datetime_to_str
 from logging import Logger
-from saviialib.general_types.error_types.api.epii_api_error_types import (
+from saviialib.general_types.error_types.api.saviia_api_error_types import (
     BackupEmptyError,
     BackupSourcePathError,
     BackupUploadError,
@@ -23,7 +23,7 @@ from saviialib.libs.sharepoint_client import (
     SpUploadFileArgs,
     SpCreateFolderArgs,
 )
-from saviialib.services.epii.utils.upload_backup_to_sharepoint_utils import (
+from saviialib.services.backup.utils.upload_backup_to_sharepoint_utils import (
     calculate_percentage_uploaded,
     count_files_in_directory,
     extract_error_message,

saviialib/services/backup/utils/__init__.py

@@ -0,0 +1,3 @@
+from ...thies.utils.update_thies_data_utils import parse_execute_response
+
+__all__ = ["parse_execute_response"]

saviialib/services/{epii → backup}/utils/upload_backup_to_sharepoint_utils.py

@@ -1,7 +1,7 @@
 import re
 from logging import Logger
 from typing import List, Dict, Optional
-from saviialib.general_types.error_types.api.epii_api_error_types import (
+from saviialib.general_types.error_types.api.saviia_api_error_types import (
     BackupSourcePathError,
 )
 from saviialib.libs.directory_client import DirectoryClient, DirectoryClientArgs

saviialib/services/netcamera/api.py

@@ -0,0 +1,30 @@
+from .controllers.get_media_files import (
+    GetMediaFilesController,
+    GetMediaFilesControllerInput,
+)
+from typing import Dict, Tuple, Any
+from saviialib.general_types.api.saviia_netcamera_api_types import SaviiaNetcameraConfig
+
+
+class NetcameraAPI:
+    """This class provides methods for interacting with network cameras and retrieving
+    files using streaming services."""
+
+    def __init__(self, config: SaviiaNetcameraConfig):
+        self.config = config
+
+    async def get_media_files(
+        self, cameras: Dict[str, Tuple[str, int]]
+    ) -> Dict[str, Any]:
+        """Retrieve media files from Network cameras.
+
+        :param cameras: Dictionary where the key is the identifier of the camera, and the
+            value is a tuple wich contains the service IP address and port of connection.
+            Example: {'cam_01': ('192.168.1.10', 8080), ...}
+        :type cameras: dict
+        :return response: A dictionary containg information of the extraction operation.
+        :rtype: dict
+        """
+        controller = GetMediaFilesController(GetMediaFilesControllerInput(cameras))
+        response = await controller.execute()
+        return response.__dict__

saviialib/services/netcamera/controllers/get_media_files.py

@@ -0,0 +1,40 @@
+from .types.get_media_files_types import (
+    GetMediaFilesControllerInput,
+    GetMediaFilesControllerOutput,
+)
+from saviialib.services.netcamera.use_cases.get_media_files import (
+    GetMediaFilesUseCase,
+    GetMediaFilesUseCaseInput,
+)
+from http import HTTPStatus
+from saviialib.general_types.error_types.api.saviia_netcamera_error_types import (
+    NetcameraConnectionError,
+)
+
+
+class GetMediaFilesController:
+    def __init__(self, input: GetMediaFilesControllerInput) -> None:
+        self.use_case = GetMediaFilesUseCase(
+            GetMediaFilesUseCaseInput(
+                cameras=input.cameras,
+                username=input.config.username,
+                password=input.config.password,
+                protocol=input.config.protocol,
+                logger=input.config.logger,
+                destination_path=input.config.destination_path,
+            )
+        )
+
+    async def execute(self) -> GetMediaFilesControllerOutput:
+        try:
+            _ = await self.use_case.execute()
+            return GetMediaFilesControllerOutput(
+                message="The extraction of media files was successfully!",
+                status=HTTPStatus.OK.value,
+            )
+        except NetcameraConnectionError as error:
+            return GetMediaFilesControllerOutput(
+                message="An unnexpected error ocurred while extractingphotos and videos.",
+                status=HTTPStatus.GATEWAY_TIMEOUT.value,
+                metadata={"error": error.__str__()},
+            )

saviialib/services/netcamera/controllers/types/get_media_files_types.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass, field
+from typing import Dict, Tuple
+from saviialib.general_types.api.saviia_netcamera_api_types import SaviiaNetcameraConfig
+
+
+@dataclass
+class GetMediaFilesControllerInput:
+    config = SaviiaNetcameraConfig
+    cameras: Dict[str, Tuple[str, int]]
+
+
+@dataclass
+class GetMediaFilesControllerOutput:
+    status: int
+    message: str
+    metadata: Dict = field(default_factory=dict)

saviialib/services/netcamera/use_cases/get_media_files.py

@@ -0,0 +1,76 @@
+from .types.get_media_files_types import (
+    GetMediaFilesUseCaseInput,
+    GetMediaFilesUseCaseOutput,
+)
+from saviialib.libs.ffmpeg_client import (
+    FfmpegClient,
+    FfmpegClientInitArgs,
+    RecordVideoArgs,
+    RecordPhotoArgs,
+)
+from saviialib.libs.zero_dependency.utils.strings_utils import are_equal
+from typing import Tuple, Dict
+from saviialib.libs.directory_client.directory_client import (
+    DirectoryClient,
+    DirectoryClientArgs,
+)
+from saviialib.general_types.error_types.api.saviia_netcamera_error_types import (
+    NetcameraConnectionError,
+)
+
+
+class GetMediaFilesUseCase:
+    def __init__(self, input: GetMediaFilesUseCaseInput) -> None:
+        self.ffmpeg_client = FfmpegClient(
+            FfmpegClientInitArgs(
+                client_name="ffmpeg_asyncio",
+            )
+        )
+        self.dir_client = DirectoryClient(DirectoryClientArgs("os_client"))
+        self.user = input.username
+        self.pwd = input.password
+        self.cameras: Dict[str, Tuple[str, int]] = input.cameras
+        self.protocol = input.protocol
+        self.logger = input.logger
+        self.dest_path = input.destination_path
+
+    async def _retieve_with_rtsp(self):
+        for name, conn in self.cameras.items():
+            ip, port = conn
+            dest_path = self.dir_client.join_paths(self.dest_path, name)
+            try:
+                # Extraction of photo files into dest_path dir.
+                await self.ffmpeg_client.record_photo(
+                    RecordPhotoArgs(
+                        ip_address=ip,
+                        port=str(port),
+                        destination_path=dest_path,
+                        rtsp_user=self.user,
+                        rtsp_password=self.pwd,
+                        extension="jpg",
+                        frames=1,
+                    )
+                )
+                # Extraction of video files into dest_path dir.
+                await self.ffmpeg_client.record_video(
+                    RecordVideoArgs(
+                        destination_path=dest_path,
+                        ip_address=ip,
+                        port=str(port),
+                        rtsp_user=self.user,
+                        rtsp_password=self.pwd,
+                        extension="mp3",
+                        duration=10,
+                    )
+                )
+            except ConnectionError as error:
+                raise NetcameraConnectionError(reason=error)
+
+    async def execute(self) -> GetMediaFilesUseCaseOutput:
+        if are_equal(self.protocol, "rtsp"):
+            await self._retieve_with_rtsp()
+        else:
+            raise NotImplementedError(
+                f"The media files extraction with {self.protocol} is not implemented yet."
+            )
+        return GetMediaFilesUseCaseOutput()

saviialib/services/netcamera/use_cases/types/get_media_files_types.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+from logging import Logger
+from typing import Dict, Tuple
+
+
+@dataclass
+class GetMediaFilesUseCaseInput:
+    cameras: Dict[str, Tuple[str, int]]
+    username: str
+    password: str
+    protocol: str
+    logger: Logger
+    destination_path: str
+
+
+@dataclass
+class GetMediaFilesUseCaseOutput:
+    pass

saviialib/services/shakes/api.py

@@ -0,0 +1,31 @@
+from .controllers.get_miniseed_files import (
+    GetMiniseedFilesController,
+    GetMiniseedFilesControllerInput,
+)
+from saviialib.general_types.api.saviia_shakes_api_types import SaviiaShakesConfig
+
+from typing import Dict
+
+
+class ShakesAPI:
+    """This class provides methods for interacting with Raspberry Shakes"""
+
+    def __init__(self, config: SaviiaShakesConfig) -> None:
+        self.config = config
+
+    async def get_miniseed_files(self, raspberry_shakes: Dict[str, str]):
+        """Download the MiniSEED files from the SFTP Server provided by each Raspberry Shake.
+        Args:
+            raspberry_shakes (dict): Dictionary where the key is the name of the Raspberry Shake,
+                and the value is the IP Address.
+        Returns:
+            response (dict): A dictionary containg the response from the download operation.
+                This response will tipically include the message, the response status, and metadata.
+        """
+        controller = GetMiniseedFilesController(
+            GetMiniseedFilesControllerInput(
+                config=self.config, raspberry_shakes=raspberry_shakes
+            )
+        )
+        response = await controller.execute()
+        return response.__dict__

saviialib/services/shakes/controllers/get_miniseed_files.py

@@ -0,0 +1,48 @@
+from .types.get_miniseed_files_types import (
+    GetMiniseedFilesControllerInput,
+    GetMiniseedFilesControllerOutput,
+)
+from saviialib.services.shakes.use_cases.get_miniseed_files import (
+    GetMiniseedFilesUseCase,
+    GetMiniseedFilesUseCaseInput,
+)
+from http import HTTPStatus
+from saviialib.general_types.error_types.api.saviia_api_error_types import (
+    ShakesNoContentError,
+)
+from saviialib.general_types.error_types.common.common_types import SftpClientError
+
+
+class GetMiniseedFilesController:
+    def __init__(self, input: GetMiniseedFilesControllerInput) -> None:
+        self.use_case = GetMiniseedFilesUseCase(
+            GetMiniseedFilesUseCaseInput(
+                raspberry_shakes=input.raspberry_shakes,
+                username=input.config.sftp_user,
+                password=input.config.sftp_password,
+                ssh_key_path=input.config.ssh_key_path,
+                port=input.config.sftp_port,
+                logger=input.config.logger,
+            )
+        )
+
+    async def execute(self) -> GetMiniseedFilesControllerOutput:
+        try:
+            res = await self.use_case.execute()
+            return GetMiniseedFilesControllerOutput(
+                message="The MiniSEED files have been downloaded succesfully!",
+                status=HTTPStatus.OK.value,
+                metadata=res.download_status,
+            )
+        except ShakesNoContentError as error:
+            return GetMiniseedFilesControllerOutput(
+                message="No files to upload.",
+                status=HTTPStatus.NO_CONTENT.value,
+                metadata={"error": error.__str__()},
+            )
+        except SftpClientError as error:
+            return GetMiniseedFilesControllerOutput(
+                message="An unexpected error ocurred during SFTP Client connection.",
+                status=HTTPStatus.REQUEST_TIMEOUT.value,
+                metadata={"error": error.__str__()},
+            )

saviialib/services/shakes/controllers/types/get_miniseed_files_types.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+from typing import Dict
+from saviialib.general_types.api.saviia_shakes_api_types import SaviiaShakesConfig
+
+
+@dataclass
+class GetMiniseedFilesControllerInput:
+    raspberry_shakes: Dict[str, str]
+    config: SaviiaShakesConfig
+
+
+@dataclass
+class GetMiniseedFilesControllerOutput:
+    status: int
+    metadata: Dict
+    message: str

saviialib/services/shakes/use_cases/get_miniseed_files.py

@@ -0,0 +1,79 @@
+import asyncio
+from .types.get_miniseed_files_types import (
+    GetMiniseedFilesUseCaseInput,
+    GetMiniseedFilesUseCaseOutput,
+)
+from typing import Dict, Any
+from saviialib.libs.sftp_client import (
+    SFTPClient,
+    SFTPClientInitArgs,
+    ListfilesArgs,
+    DownloadfilesArgs,
+)
+from saviialib.libs.directory_client import DirectoryClient, DirectoryClientArgs
+from saviialib.general_types.error_types.api.saviia_api_error_types import (
+    ShakesNoContentError,
+)
+from saviialib.general_types.error_types.common.common_types import SftpClientError
+from .utils.get_miniseed_files_utils import parse_downloaded_metadata
+
+
+class GetMiniseedFilesUseCase:
+    def __init__(self, input: GetMiniseedFilesUseCaseInput) -> None:
+        self.password = input.password
+        self.username = input.username
+        self.ssh_key_path = input.ssh_key_path
+        self.port = input.port
+        self.raspberry_shakes: Dict[str, str] = input.raspberry_shakes
+        self.dir_client = DirectoryClient(DirectoryClientArgs("os_client"))
+
+    def _initialize_sftp_client(self, ip_address: str):
+        return SFTPClient(
+            SFTPClientInitArgs(
+                "asyncssh_sftp",
+                password=self.password,
+                username=self.username,
+                ssh_key_path=self.ssh_key_path,
+                host=ip_address,
+                port=self.port,
+            )
+        )
+
+    async def _download_mseed_file(self, rs_name: str, rs_ip: str) -> Dict[str, Any]:
+        DEST_BASE_DIR = "./rshakes-mseed-files"
+        SOURCE_PATH = self.dir_client.join_paths("opt", "data", "archive")
+        local_path = self.dir_client.join_paths(DEST_BASE_DIR, rs_name)
+        if not await self.dir_client.isdir(local_path):
+            await self.dir_client.makedirs(local_path)
+        sftp_client = self._initialize_sftp_client(rs_ip)
+
+        local_files = await self.dir_client.listdir(local_path)
+        try:
+            sftp_files = await sftp_client.list_files(ListfilesArgs(path=SOURCE_PATH))
+            pending_files = set(sftp_files) - set(local_files)
+            if not pending_files:
+                raise ShakesNoContentError
+
+            await sftp_client.download_files(
+                DownloadfilesArgs(
+                    source_path=SOURCE_PATH,
+                    destination_path=local_path,
+                    files_to_download=list(pending_files),
+                )
+            )
+        except ConnectionError as error:
+            raise SftpClientError(reason=error)
+        return {
+            "rs_name": rs_name,
+            "destination_path": local_path,
+            "total_files": len(pending_files),
+        }
+
+    async def execute(self):
+        requests = []
+        for rs_name, rs_ip in self.raspberry_shakes:
+            requests.append(self._download_mseed_file(rs_name, rs_ip))
+        responses = await asyncio.gather(*requests, return_exceptions=True)
+        return GetMiniseedFilesUseCaseOutput(
+            download_status=parse_downloaded_metadata(responses),
+        )

saviialib/services/shakes/use_cases/types/get_miniseed_files_types.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass, field
+from typing import Dict
+from logging import Logger
+
+
+@dataclass
+class GetMiniseedFilesUseCaseInput:
+    raspberry_shakes: Dict[str, str]
+    username: str
+    password: str
+    ssh_key_path: str
+    port: int
+    logger: Logger
+
+
+@dataclass
+class GetMiniseedFilesUseCaseOutput:
+    download_status: Dict[str, str] = field(default_factory=dict)

saviialib/services/shakes/use_cases/utils/get_miniseed_files_utils.py

@@ -0,0 +1,11 @@
+from typing import Dict, List, Any
+
+
+def parse_downloaded_metadata(responses: List[Any]) -> Dict[str, Any]:
+    return {
+        x["rs_name"]: {
+            "destination_path": x["destination_path"],
+            "total_files": x["total_files"],
+        }
+        for x in responses
+    }

saviialib/services/thies/api.py

@@ -0,0 +1,35 @@
+from typing import Any, Dict, List
+
+from .controllers.types.update_thies_data_types import UpdateThiesDataControllerInput
+from .controllers.update_thies_data import UpdateThiesDataController
+from saviialib.general_types.api.saviia_thies_api_types import (
+    SaviiaThiesConfig,
+)
+
+
+class SaviiaThiesAPI:
+    def __init__(self, config: SaviiaThiesConfig) -> None:
+        self.config = config
+
+    async def update_thies_data(
+        self, sharepoint_folders_path: List[str], ftp_server_folders_path: List[str]
+    ) -> Dict[str, Any]:
+        """Updates data from a THIES Data Logger by connecting to an FTP server
+        and transferring data to specified Sharepoint folders.
+
+        Args:
+            sharepoint_folders_path (list): List of Sharepoint folder paths for AVG and EXT data.
+            The AVG path must be the first element.
+            ftp_server_folders_path (list): List of FTP server folder paths for AVG and EXT data.
+            The AVG path must be the first element.
+
+        Returns:
+            dict: A dictionary representation of the API response.
+        """
+        controller = UpdateThiesDataController(
+            UpdateThiesDataControllerInput(
+                self.config, sharepoint_folders_path, ftp_server_folders_path
+            )
+        )
+        response = await controller.execute()
+        return response.__dict__

saviialib/services/{epii → thies}/controllers/types/update_thies_data_types.py

@@ -1,13 +1,11 @@
 from dataclasses import dataclass, field
 from typing import Dict
-from saviialib.general_types.api.epii_api_types import (
-    EpiiUpdateThiesConfig,
-)
+from saviialib.general_types.api.saviia_thies_api_types import SaviiaThiesConfig
 
 
 @dataclass
 class UpdateThiesDataControllerInput:
-    config: EpiiUpdateThiesConfig
+    config: SaviiaThiesConfig
     sharepoint_folders_path: list
     ftp_server_folders_path: list
 

saviialib/services/{epii → thies}/controllers/update_thies_data.py

@@ -1,6 +1,6 @@
 from http import HTTPStatus
 
-from saviialib.general_types.error_types.api.epii_api_error_types import (
+from saviialib.general_types.error_types.api.saviia_api_error_types import (
     SharePointFetchingError,
     ThiesConnectionError,
     ThiesFetchingError,
@@ -12,16 +12,16 @@ from saviialib.general_types.error_types.common.common_types import (
     FtpClientError,
     SharepointClientError,
 )
-from saviialib.services.epii.controllers.types.update_thies_data_types import (
+from saviialib.services.thies.controllers.types.update_thies_data_types import (
     UpdateThiesDataControllerInput,
     UpdateThiesDataControllerOutput,
 )
-from saviialib.services.epii.use_cases.types import (
+from saviialib.services.backup.use_cases.types import (
     UpdateThiesDataUseCaseInput,
     SharepointConfig,
     FtpClientConfig,
 )
-from saviialib.services.epii.use_cases.update_thies_data import (
+from saviialib.services.thies.use_cases.update_thies_data import (
     UpdateThiesDataUseCase,
 )
 

saviialib/services/{epii → thies}/use_cases/components/create_thies_statistics_file.py

@@ -1,5 +1,4 @@
 from .thies_bp import THIESDayData
-from typing import List
 from logging import Logger
 from asyncio import to_thread
 from saviialib.libs.directory_client import DirectoryClient
@@ -70,7 +69,7 @@ UNITS = {
 
 
 async def create_thies_daily_statistics_file(
-    os_client: DirectoryClient, logger: Logger, daily_files: List[str]
+    os_client: DirectoryClient, logger: Logger
 ) -> None:
     logger.debug("[thies_synchronization_lib] Creating Daily Statistics ...")
     csv_client = FilesClient(FilesClientInitArgs(client_name="csv_client"))
@@ -127,6 +126,16 @@ async def create_thies_daily_statistics_file(
             if max_col not in row:
                 max_val = 0
 
+            if (mean < min_val or mean > max_val) and col not in ["WD"]:
+                logger.warning(
+                    f"[thies_synchronization_lib] Inconsistent data for {col}: "
+                    f"min {min_val}, max {max_val}, mean {mean}. "
+                )
+                mean = (min_val + max_val) / 2
+                logger.warning(
+                    f"[thies_synchronization_lib] Mean value corrected to {mean}."
+                )
+
             if col in ["WD"]:  # Avoid error
                 rows.append(
                     {

saviialib/services/{epii → thies}/use_cases/types/update_thies_data_types.py

@@ -1,6 +1,9 @@
 from dataclasses import dataclass, field
 from typing import Dict, List
-from saviialib.general_types.api.epii_api_types import FtpClientConfig, SharepointConfig
+from saviialib.general_types.api.saviia_api_types import (
+    FtpClientConfig,
+    SharepointConfig,
+)
 from logging import Logger