statsuite-lib 0.1.3__tar.gz

statsuite_lib-0.1.3/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.3
+Name: statsuite_lib
+Version: 0.1.3
+Summary: 
+Author: Sergio Pena
+Author-email: isergiopena@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: httpx (>=0.28.1,<0.29.0)
+Requires-Dist: pydantic (==2.9.2)
+Description-Content-Type: text/markdown
+
+# StatSuite-lib
+
+StatSuite-lib is an opinionated library to interact with dotStatSuite components.
+There is no full coverage of the APIs, it will be completed as needed.
+
+## Installation
+
+Use the package manager [pip](https://pip.pypa.io/en/stable/) to install statsuite-lib.
+
+```bash
+pip install statsuite-lib
+```
+
+## Usage
+
+Check the documentation, mainly the statsuite-cli repo can serve as example on how to use this library
+Keycloak client must be initialized and pass to any other client requiring authentication to manage the token creation and renewal
+
+```python
+from statsuite_lib import SFSClient, KeycloakClient
+
+
+OPENID_URL = "http://localhost:8080/auth/realms/demo/.well-known/openid-configuration"
+KEYCLOAK_USER = 'test-admin'
+KEYCLOAK_PASSWORD = 'admin'
+SFS_API_KEY = 'secret'
+SFS_URL = 'http://localhost:3004'
+
+keycloak = KeycloakClient(openid_url=OPENID_URL,
+                          username=KEYCLOAK_USER,
+                          password=KEYCLOAK_PASSWORD)
+
+
+sfs = SFSClient(sfs_url=SFS_URL, sfs_api_key=SFS_API_KEY)
+
+id = sfs.index()
+
+print(f"Index started with id {id}")
+sfs.wait_for_reindex_to_finish(loading_id=id, tenant='default')
+```
+
+## Contributing
+
+Pull requests are welcome. For major changes, please open an issue first
+to discuss what you would like to change.
+
+Please make sure to update tests as appropriate.
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)

statsuite_lib-0.1.3/README.md

@@ -0,0 +1,51 @@
+# StatSuite-lib
+
+StatSuite-lib is an opinionated library to interact with dotStatSuite components.
+There is no full coverage of the APIs, it will be completed as needed.
+
+## Installation
+
+Use the package manager [pip](https://pip.pypa.io/en/stable/) to install statsuite-lib.
+
+```bash
+pip install statsuite-lib
+```
+
+## Usage
+
+Check the documentation, mainly the statsuite-cli repo can serve as example on how to use this library
+Keycloak client must be initialized and pass to any other client requiring authentication to manage the token creation and renewal
+
+```python
+from statsuite_lib import SFSClient, KeycloakClient
+
+
+OPENID_URL = "http://localhost:8080/auth/realms/demo/.well-known/openid-configuration"
+KEYCLOAK_USER = 'test-admin'
+KEYCLOAK_PASSWORD = 'admin'
+SFS_API_KEY = 'secret'
+SFS_URL = 'http://localhost:3004'
+
+keycloak = KeycloakClient(openid_url=OPENID_URL,
+                          username=KEYCLOAK_USER,
+                          password=KEYCLOAK_PASSWORD)
+
+
+sfs = SFSClient(sfs_url=SFS_URL, sfs_api_key=SFS_API_KEY)
+
+id = sfs.index()
+
+print(f"Index started with id {id}")
+sfs.wait_for_reindex_to_finish(loading_id=id, tenant='default')
+```
+
+## Contributing
+
+Pull requests are welcome. For major changes, please open an issue first
+to discuss what you would like to change.
+
+Please make sure to update tests as appropriate.
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)

statsuite_lib-0.1.3/pyproject.toml

@@ -0,0 +1,54 @@
+[tool.poetry]
+name = "statsuite_lib"
+version = "0.1.3"
+description = ""
+authors = ["Sergio Pena <isergiopena@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.11,<4.0"
+httpx = "^0.28.1"
+pydantic = "2.9.2"
+
+[tool.poetry.requires-plugins]
+poetry-plugin-export = ">=1.8"
+
+[tool.poetry.group.dev.dependencies]
+pytest-httpx = "^0.35.0"
+pytest = "^8.3.4"
+pytest-coverage = "^0.0"
+pytest-mock = "^3.14.0"
+bandit = "^1.8.0"
+flake8-simplify = "^0.21.0"
+black = "^24.10.0"
+flake8-variables-names = "^0.0.6"
+flake8-functions-names = "^0.4.0"
+flake8-cognitive-complexity = "^0.1.0"
+flake8-expression-complexity = "^0.0.11"
+flake8-docstrings-complete = "^1.4.1"
+flake8-black = "^0.3.6"
+flake8-bandit = "^4.1.1"
+flake8-isort = "^6.1.1"
+safety = "^3.2.14"
+flake8-pyproject = "^1.2.3"
+freezegun = "^1.5.3"
+cryptography = ">=44.0.2"
+sphinx = "^8.2.3"
+pdoc = "^15.0.4"
+sphinx-rtd-theme = "^3.0.2"
+myst-parser = "^4.0.1"
+sphinx-toolbox = "^4.0.0"
+pip = "^25.2"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.flake8]
+exclude = ['.poetry']
+ignore = ['E231', 'E241']
+per-file-ignores = [
+    '__init__.py:F401',
+    'tests/*py:S101',
+]
+max-line-length = 95

statsuite_lib-0.1.3/statsuite_lib/__init__.py

@@ -0,0 +1,6 @@
+from .auth import AuthClient
+from .config import ConfigClient
+from .keycloak import KeycloakClient
+from .nsi import NSIClient
+from .sfs import SFSClient
+from .transfer import TransferClient

statsuite_lib-0.1.3/statsuite_lib/auth/__init__.py

@@ -0,0 +1 @@
+from .auth import AuthClient

statsuite_lib-0.1.3/statsuite_lib/auth/auth.py

@@ -0,0 +1,96 @@
+import logging
+
+import httpx
+
+from ..keycloak.keycloak import KeycloakClient
+
+
+class AuthClient:
+    """A client for managing authorization rules through the Auth API.
+
+    This client handles the communication with the authorization service,
+    allowing for the management of access rules and permissions.
+
+    Attributes:
+        AUTH_URL (str): The complete URL for the Auth API including version.
+
+    Args:
+        auth_url (str): Base URL of the authorization service.
+        keycloak_client (KeycloakClient): Client for handling Keycloak authentication.
+        api_version (str, optional): API version to use. Defaults to "1.1".
+    """
+
+    def __init__(
+        self, auth_url: str, keycloak_client: KeycloakClient, api_version: str = "1.1"
+    ) -> None:
+        """Initialize the AuthClient.
+
+        Creates a new instance of the AuthClient with the specified configuration.
+        Sets up an HTTP client and configures logging.
+
+        Args:
+            auth_url (str): Base URL of the authorization service endpoint.
+                Should not include the version number.
+            keycloak_client (KeycloakClient): An initialized Keycloak client instance
+                used for authentication headers.
+            api_version (str, optional): API version string to use in URL construction.
+                Defaults to "1.1".
+
+        Example:
+            keycloak_client = KeycloakClient(...)
+            auth_client = AuthClient(
+                auth_url="https://auth.example.com",
+                keycloak_client=keycloak_client
+            )
+        """
+
+        self._client = httpx.Client()
+        self.AUTH_URL = f"{auth_url}/{api_version}"
+        self._keycloak_client = keycloak_client
+        self._log = logging.getLogger("AuthClient")
+
+    def add_rule(
+        self,
+        user_mask: str,
+        is_group: bool,
+        permission=int,
+        dataspace: str = "*",
+        artifact_type: int = 0,
+        artefact_agency_id: str = "*",
+        artefact_id: str = "*",
+        artefact_version: str = "*",
+    ):
+        """Add a new authorization rule to the system.
+
+        Args:
+            user_mask (str): The user or group identifier pattern.
+            is_group (bool): Whether the rule applies to a group (True) or user (False).
+            permission (int): The permission level to grant.
+            dataspace (str, optional): Target dataspace. Defaults to "*" (all dataspaces).
+            artifact_type (int, optional): Type of artifact. Defaults to 0.
+            artefact_agency_id (str, optional): Agency ID of the artifact. Defaults to "*".
+            artefact_id (str, optional): ID of the artifact. Defaults to "*".
+            artefact_version (str, optional): Version of the artifact. Defaults to "*".
+
+        Returns:
+            dict: The JSON response from the server containing the created rule.
+
+        """
+
+        data = {
+            "userMask": user_mask,
+            "isGroup": is_group,
+            "dataSpace": dataspace,
+            "artefactType": artifact_type,
+            "artefactAgencyId": artefact_agency_id,
+            "artefactId": artefact_id,
+            "artefactVersion": artefact_version,
+            "permission": permission,
+        }
+
+        url = f"{self.AUTH_URL}/AuthorizationRules"
+        response = httpx.post(
+            url=url, headers=self._keycloak_client.auth_header(), data=data
+        )
+        response.raise_for_status()
+        return response.json()

statsuite_lib-0.1.3/statsuite_lib/config/__init__.py

@@ -0,0 +1 @@
+from .config import ConfigClient

statsuite_lib-0.1.3/statsuite_lib/config/config.py

@@ -0,0 +1,47 @@
+import logging
+from typing import Iterator
+
+import httpx
+
+from .models import Space, Tenants
+
+
+class ConfigClient:
+    """Client for the SDMX Faceted search service"""
+
+    def __init__(self, config_url: str) -> None:
+        """Inits the client
+
+        Args:
+            config_url: Endpoint url for Config service.
+        """
+
+        self._client = httpx.Client()
+        self.CONFIG_URL = config_url
+        self.log = logging.getLogger("ConfigClient")
+        self.log.level = logging.INFO
+
+    def get_tenants(self) -> str:
+        """Gets tenants config
+
+        Returns:
+            loadingId(str)
+        """
+        resp = httpx.get(f"{self.CONFIG_URL}/configs/tenants.json")
+        if resp.status_code == 200:
+            loading = Tenants.model_validate(resp.json())
+            return loading
+
+    def get_dataspaces(self, tenant: str = "default") -> Iterator[Space]:
+        """Returns a list of dataspaces configured for a tenant
+
+        Args:
+            tenant: select which tenant
+
+        Yields:
+        Space: A dataspace configuration object for each space in the tenant.
+        """
+        tenants = self.get_tenants()
+        spaces = tenants.root.get(tenant).spaces
+        for space in spaces:
+            yield spaces.get(space)

statsuite_lib-0.1.3/statsuite_lib/config/models.py

@@ -0,0 +1,49 @@
+from typing import Dict, Union
+
+from pydantic import BaseModel, ConfigDict, RootModel
+
+
+class Index(RootModel):
+    """Model for return json from indexing request on SFS
+
+    Attributes:
+        root: returns a json in the format { "loadingId": ######### }
+    """
+
+    root: Dict[str, Union[str, Dict]]
+
+
+class Space(BaseModel):
+    """Model for spaces inside tenants
+
+    Attributes:
+        id: Space id
+        url: space url
+    """
+
+    id: str  # noqa VNE003
+    url: str
+
+
+class Tenant(BaseModel):
+    """Minimun model for Loading Log entity
+
+    Attributes:
+        model_config: Configuration
+        id: Loadingid
+        spaces: Dict of spaces inside tenant
+    """
+
+    model_config = ConfigDict(extra="allow")
+    id: str  # noqa VNE003
+    spaces: Dict[str, Space]
+
+
+class Tenants(RootModel):
+    """Collection of loading log entries
+
+    Attributes:
+        root: Collection of Loadings without key
+    """
+
+    root: Dict[str, Tenant]

statsuite_lib-0.1.3/statsuite_lib/keycloak/__init__.py

@@ -0,0 +1 @@
+from .keycloak import KeycloakClient

statsuite_lib-0.1.3/statsuite_lib/keycloak/keycloak.py

@@ -0,0 +1,147 @@
+import datetime
+import logging
+
+import httpx
+
+
+class KeycloakClient:
+    """
+    A client for handling Keycloak authentication and token management.
+
+    This class manages OAuth2/OpenID Connect authentication with Keycloak,
+    including token acquisition, refresh, and management.
+
+    Args:
+        openid_url (str): The OpenID configuration URL for the Keycloak server
+        username (str): Username for authentication
+        password (str): Password for authentication
+    """
+
+    def __init__(self, openid_url: str, username: str, password: str) -> None:
+        """
+        Initialize the KeycloakClient with authentication credentials.
+
+        Args:
+            openid_url (str): The OpenID configuration URL for the Keycloak server
+            username (str): Username for authentication
+            password (str): Password for authentication
+        """
+
+        self._client = httpx.Client()
+        self.OPENID_URL = openid_url
+        self.log = logging.getLogger("KeycloakClient")
+        self._auth_endpoint = None
+        self._token_endpoint = None
+        self.access_token = None
+        self.access_token_expires = None
+        self.refresh_token = None
+        self._get_openid_configuration()
+        self._authenticate(username=username, password=password)
+
+    def _get_openid_configuration(self) -> None:
+        """
+        Retrieve OpenID Connect configuration from Keycloak server.
+
+        This method fetches the authorization and token endpoints from the
+        Keycloak OpenID configuration.
+
+        Raises:
+            ConnectError: If connection to the Keycloak server fails.
+        """
+        self.log.info(f"Getting openid configuration from {self.OPENID_URL}")
+        try:
+
+            response = self._client.get(self.OPENID_URL)
+            self._auth_endpoint = response.json()["authorization_endpoint"]
+            self._token_endpoint = response.json()["token_endpoint"]
+
+        except httpx.ConnectError as e:
+            raise httpx.ConnectError(f"Failed to get openid configuration: {e}")
+
+    def _authenticate(self, username: str, password: str) -> None:
+        """
+        Perform initial authentication with Keycloak using username and password.
+
+        This method obtains the initial access and refresh tokens using the
+        provided credentials.
+
+        Args:
+            username (str): Username for authentication
+            password (str): Password for authentication
+
+
+        """
+
+        self.log.info(f"Authenticating with {self._auth_endpoint}")
+        response = self._client.post(
+            self._token_endpoint,
+            data={
+                "grant_type": "password",
+                "client_id": "stat-suite",
+                "username": username,
+                "password": password,
+            },
+        )
+
+        self.refresh_token = response.json()["refresh_token"]
+        self.access_token = response.json()["access_token"]
+        self.access_token_expires = datetime.datetime.now() + datetime.timedelta(
+            seconds=response.json()["expires_in"]
+        )
+
+    def trigger_refresh_token(self) -> None:
+        """
+        Refresh the access token using the refresh token.
+
+        This method is called when the access token is expired or about to expire.
+        It uses the refresh token to obtain a new access token and refresh token pair.
+
+
+        """
+
+        self.log.info("Triggering refresh token")
+        response = self._client.post(
+            self._token_endpoint,
+            data={
+                "grant_type": "refresh_token",
+                "client_id": "stat-suite",
+                "refresh_token": self.refresh_token,
+            },
+        )
+        self.access_token = response.json()["access_token"]
+        self.access_token_expires = datetime.datetime.now() + datetime.timedelta(
+            seconds=response.json()["expires_in"]
+        )
+        self.refresh_token = response.json()["refresh_token"]
+
+    def get_access_token(self) -> str:
+        """
+        Get the current valid access token.
+
+        This method checks if the current access token is valid and not expired.
+        If expired, it automatically triggers a token refresh.
+
+        Returns:
+            Access token string
+        """
+
+        self.log.info("Getting access token")
+        if (
+            self.access_token_expires is None
+            or self.access_token_expires < datetime.datetime.now()  # noqa W503
+        ):
+            self.trigger_refresh_token()
+
+        return self.access_token
+
+    def auth_header(self) -> dict:
+        """
+        Create an authorization header using the current access token.
+
+        Returns:
+            dict: A dictionary containing the Authorization header with the Bearer token
+                 in the format {'Authorization': 'Bearer <token>'}
+
+        """
+
+        return {"Authorization": f"Bearer {self.get_access_token()}"}

statsuite_lib-0.1.3/statsuite_lib/nsi/__init__.py

@@ -0,0 +1 @@
+from .nsi import NSIClient

statsuite_lib-0.1.3/statsuite_lib/nsi/nsi.py

@@ -0,0 +1,101 @@
+import logging
+
+import httpx
+
+from ..keycloak.keycloak import KeycloakClient
+
+
+class NSIClient:
+    """Client for interacting with the NSI (Network Service Interface) API.
+
+    This client handles file operations (upload, download, delete) through the NSI service
+    with authentication handled by a Keycloak client.
+
+    Attributes:
+        NSI_URL (str): Base URL for the NSI service.
+        log: Logger instance for the NSIClient.
+
+    Args:
+        nsi_url (str): Base URL of the NSI service.
+        keycloak_client (KeycloakClient): Client for handling Keycloak authentication.
+    """
+
+    def __init__(self, nsi_url: str, keycloak_client: KeycloakClient) -> None:
+        """Initialize the NSIClient.
+
+        Args:
+            nsi_url (str): Base URL of the NSI service.
+            keycloak_client (KeycloakClient): Initialized Keycloak client for authentication.
+        """
+        self._client = httpx.Client()
+        self.NSI_URL = nsi_url
+        self._keycloak_client = keycloak_client
+        self.log = logging.getLogger("NSIClient")
+
+    def put(self, file_to_upload, path: str, timeout: int = None) -> int:
+        """Upload a file to the NSI service.
+
+        Args:
+            file_to_upload: File content to upload.
+            path (str): Target path on the NSI service.
+            timeout (int, optional): Request timeout in seconds. Defaults to None.
+
+        Returns:
+            int: HTTP status code of the upload response.
+
+        """
+
+        headers = self._keycloak_client.auth_header() | {
+            "Content-Type": "application/x-www-form-urlencoded"
+        }
+
+        self.log.info(f"Uploading to NSI: {self.NSI_URL + path}")
+
+        response = httpx.post(
+            self.NSI_URL + path,
+            content=file_to_upload,
+            headers=headers,
+            timeout=timeout,
+        )
+
+        if response.status_code != 207:
+            self.log.info(f"NSI response: {response.text}")
+        self.log.info(response.text)
+        response.raise_for_status()
+        return response.status_code
+
+    def get(self, path: str, headers: dict = {}, timeout: int = None) -> httpx.Response:
+        """Retrieve a file or resource from the NSI service.
+
+        Args:
+            path (str): Path to the resource on the NSI service.
+            headers (dict, optional): Additional HTTP headers to include. Defaults to {}.
+            timeout (int, optional): Request timeout in seconds. Defaults to None.
+
+        Returns:
+            httpx.Response: Response object containing the requested resource.
+        """
+
+        headers |= self._keycloak_client.auth_header()
+        self.log.info(f"Getting from NSI: {self.NSI_URL + path}")
+        resp = httpx.get(self.NSI_URL + path, headers=headers, timeout=timeout)
+        resp.raise_for_status()
+        return resp
+
+    def delete(self, path: str, timeout: int = None) -> int:
+        """Delete a file or resource from the NSI service.
+
+        Args:
+            path (str): Path to the resource to delete on the NSI service.
+            timeout (int, optional): Request timeout in seconds. Defaults to None.
+
+        Returns:
+            int: HTTP status code of the delete response.
+
+        """
+
+        headers = self._keycloak_client.auth_header()
+        self.log.info(f"Deleting from NSI: {self.NSI_URL + path}")
+        response = httpx.delete(self.NSI_URL + path, headers=headers, timeout=timeout)
+        response.raise_for_status()
+        return response.status_code

statsuite_lib-0.1.3/statsuite_lib/sfs/__init__.py

@@ -0,0 +1 @@
+from .sfs import SFSClient

statsuite_lib-0.1.3/statsuite_lib/sfs/models.py

@@ -0,0 +1,39 @@
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, RootModel
+
+
+class Index(RootModel):
+    """Model for return json from indexing request on SFS
+
+    Attributes:
+        root: returns a json in the format { "loadingId": ######### }
+    """
+
+    root: Dict[str, int]
+
+
+class LoadingLog(BaseModel):
+    """Minimun model for Loading Log entity
+
+    Attributes:
+        model_config: Configuration
+        executionStart: Timestamp start of the task
+        executionStatus: Status of the task
+        id: Loadingid
+    """
+
+    model_config = ConfigDict(extra="allow")
+    executionStart: str
+    executionStatus: Optional[str] = None
+    id: int  # noqa
+
+
+class LoadingLogs(RootModel):
+    """Collection of loading log entries
+
+    Attributes:
+        root: Collection of Loadings without key
+    """
+
+    root: List[LoadingLog]

statsuite_lib-0.1.3/statsuite_lib/sfs/sfs.py

@@ -0,0 +1,148 @@
+import logging
+import time
+from enum import IntEnum
+from typing import Optional
+
+import httpx
+
+from .models import LoadingLog, LoadingLogs
+
+
+class SFSClient:
+    """Client for the SDMX Faceted search service"""
+
+    def __init__(self, sfs_url: str, sfs_api_key: str) -> None:
+        """Inits the client
+
+        Args:
+            sfs_url: Endpoint url for SFS service.
+            sfs_api_key: API key for the SFS service
+        """
+
+        self._client = httpx.Client()
+        self.SFS_URL = sfs_url
+        self._sfs_api_key = sfs_api_key
+        self.log = logging.getLogger("SFSClient")
+        self.log.level = logging.INFO
+
+    def index(self, tenant: str = "default") -> str:
+        """Triggers a new indexing task
+
+        Args:
+            tenant: (str) tenant to trigger the index for
+
+        Returns:
+            loadingId(str)
+        """
+        resp = httpx.post(
+            f"{self.SFS_URL}/admin/dataflows?api-key={self._sfs_api_key}&tenant={tenant}"  # noqa
+        )
+        if resp.status_code == 200:
+            from .models import Index
+
+            loading = Index.model_validate(resp.json())
+            return loading.root.get("loadingId")
+
+    class LoadingStatus(IntEnum):
+        """Enum class to represent status of the loading tasks
+
+        Attributes:
+            COMPLETED: Task finished succesfully
+            RETRY: Some recoverable error happened or the task is in a non-complete
+                   status
+            FAILED: Unrecoverable error
+            BUG502: There si a bug retrieving loading status that can be retrieve
+                    fetching the logs without id query param
+        """
+
+        COMPLETED = 1
+        RETRY = 2
+        FAILED = 3
+        BUG502 = 10
+
+    def get_log(self, tenant: str, loading_id: str) -> Optional[LoadingLog]:
+        """Get log and status from by loading_id, if retrieving a log by id
+        fails with a 502 it will fallback to retrieve all available logs and
+        filter them
+
+        Arguments:
+            tenant: (str) .stat tenant
+            loading_id: (str) id of the loading
+
+        Returns:
+            LoadingLog or None if the loading_id cannot be found
+        """
+
+        resp = httpx.get(
+            url=f"{self.SFS_URL}/admin/logs?api-key={self._sfs_api_key}&tenant={tenant}"
+        )
+        if resp.status_code == 200:
+            return LoadingLog.model_validate(resp.json())
+        if resp.status_code == 502:
+            self.log.error("Error 502 getting loading log, using expensive query")
+            resp = httpx.get(
+                f"{self.SFS_URL}/admin/logs?api-key={self._sfs_api_key}&tenant={tenant}"
+            )  # noqa
+            loadings = LoadingLogs.model_validate(resp.json())
+            for loading in loadings.root:
+                if str(loading.id) == loading_id:
+                    return loading
+        self.log.error(f"Error gathering logs {resp.text}")
+
+    def check_status_loading(self, tenant: str, loading_id: str) -> LoadingStatus:
+        """Check the status of a loading taks
+
+        Arguments:
+            tenant: (str) .stat tenant
+            loading_id: (str) id of the loading
+
+        Returns:
+            LoadingStatus enumeration
+        """
+        loading = self.get_log(tenant=tenant, loading_id=loading_id)
+        if loading.executionStatus == "completed":
+            return self.LoadingStatus.COMPLETED
+        else:
+            self.log.error(f"Mapping outcome of {loading.executionStatus} to RETRY")
+            return self.LoadingStatus.RETRY
+
+    def wait_for_index_to_finish(  # noqa FNE005
+        self,
+        tenant: str,
+        loading_id: str,
+        startup_sleep: int = 0,
+        timeout: int = 600,
+        backoff: int = 30,
+    ) -> bool:
+        """This method will periodically check the status of a loading task and
+        until it finishes, error or expires the timeout
+
+        Arguments:
+            tenant: (str) .stat tenant
+            loading_id: (str) id of the loading
+            startup_sleep: (int) grace period (secs) before start fetching the
+                           loading state
+            timeout: (int) max time (secs) the loop will be running
+            backoff: (int) time between iterations fetching the data
+
+        Returns:
+            boolean stating if the loading task finished correctly
+        """
+        start = time.time()
+        time.sleep(startup_sleep)
+
+        self.log.info("STARTING")
+        while True:
+            status = self.check_status_loading(tenant=tenant, loading_id=loading_id)
+            if status == self.LoadingStatus.COMPLETED:
+                return True
+
+            if time.time() - start > timeout:
+                self.log.error(
+                    f"Timeout waiting for dataflows to be indexed {timeout} seconds passed"  # noqa
+                )
+                return False
+            self.log.error(
+                "Still not information retrieved about the loading, waiting..."
+            )
+            time.sleep(backoff)

statsuite_lib-0.1.3/statsuite_lib/transfer/__init__.py

@@ -0,0 +1 @@
+from .transfer import TransferClient

statsuite_lib-0.1.3/statsuite_lib/transfer/transfer.py

@@ -0,0 +1,218 @@
+import logging
+import time
+
+import httpx
+
+from statsuite_lib import KeycloakClient
+
+
+class TransferClient:
+    """
+    A client for handling SDMX file transfers and dataflow operations.
+
+    Args:
+        transfer_url (str): Base URL for the transfer service
+        keycloak_client (KeycloakClient): Authentication client instance
+        api_version (str, optional): API version to use. Defaults to '3'
+    """
+
+    def __init__(
+        self, transfer_url: str, keycloak_client: KeycloakClient, api_version: str = "3"
+    ) -> None:
+        """
+        Initialize the TransferClient.
+
+        Args:
+            transfer_url (str): Base URL for the transfer service
+            keycloak_client (KeycloakClient): Authentication client instance
+            api_version (str, optional): API version to use. Defaults to '3'
+        """
+        self._client = httpx.Client()
+        self.TRANSFER_URL = f"{transfer_url}/{api_version}"
+        self._keycloak_client = keycloak_client
+        self._log = logging.getLogger("TransferClient")
+
+    def import_sdmx_file(
+        self,
+        file_object,
+        dataspace: str,
+        target_version: int = 0,
+        restoration_option_required: bool = False,
+        validation_type: int = 1,
+        timeout: int = None,
+    ) -> int:
+        """
+        Import an SDMX file into the specified dataspace.
+
+        Args:
+            file_object: The SDMX file to import
+            dataspace (str): Target dataspace name
+            target_version (int, optional): Version number for the import. Defaults to 0
+            restoration_option_required (bool, optional): Whether restoration is required. Defaults to False # noqa E501
+            validation_type (int, optional): Type of validation to perform. Defaults to 1
+            timeout (int, optional): Request timeout in seconds. Defaults to None
+
+        Returns:
+            int: The ID of the import request
+
+        Raises:
+            httpx.HTTPError: If the request fails
+
+        Example:
+                for csv_file in sample_data_dir.rglob("*.csv"):
+                    with open(csv_file, 'rb') as file:
+                        id = transfer.import_sdmx_file(file=file, dataspace='design')
+        """
+        data = {
+            "dataspace": dataspace,
+            "targetVersion": target_version,
+            "restorationOptionRequired": restoration_option_required,
+            "validationType": validation_type,
+        }
+        files = {"file": file_object}
+        url = f"{self.TRANSFER_URL}/import/sdmxFile"
+        resp = httpx.post(
+            url=url,
+            headers=self._keycloak_client.auth_header(),
+            data=data,
+            files=files,
+            timeout=timeout,
+        )
+        return resp.json().get("message").split(" ")[2]
+
+    def check_request_status(self, dataspace: str, id: int) -> str:  # noqa VNE003
+        """
+        Check the status of a request for a given dataspace and ID.
+
+        Args:
+            dataspace (str): The dataspace name
+            id (int): The request ID to check
+
+        Returns:
+            str: The execution status of the request
+
+        """
+        self._log.info(f"Checking request status for dataspace {dataspace} and id {id}")
+        data = {"dataspace": dataspace, "id": id}
+        resp = httpx.post(
+            url=f"{self.TRANSFER_URL}/status/request",
+            headers=self._keycloak_client.auth_header(),
+            data=data,
+        )
+        return resp.json().get("executionStatus")
+
+    def wait_for_request(
+        self,
+        dataspace: str,
+        id: int,  # noqa VNE003
+        timeout: int = 300,
+        backoff: int = 30,  # noqa VNE003
+    ) -> None:
+        """
+        Wait for a request to complete with timeout and backoff mechanism.
+
+        Args:
+            dataspace (str): The dataspace name
+            id (int): The request ID to wait for
+            timeout (int, optional): Maximum time to wait in seconds. Defaults to 300
+            backoff (int, optional): Time between status checks in seconds. Defaults to 30
+
+        Returns:
+            bool: True if timeout occurred, False if request completed successfully
+
+
+        """
+        start = time.time()
+        while True:
+            status = self.check_request_status(dataspace=dataspace, id=id)
+            if status == "Completed":
+                return False
+
+            if time.time() - start > timeout:
+                self._log.error(
+                    f"Timeout waiting for request to be completed {timeout} seconds passed"
+                )
+                return True
+            time.sleep(backoff)
+
+    def transfer_dataflow(
+        self, source_dataspace: str, destination_dataspace: str, dataflow: str
+    ):
+        """
+        Transfer a dataflow from source dataspace to destination dataspace.
+
+        Args:
+            source_dataspace (str): Source dataspace name
+            destination_dataspace (str): Destination dataspace name
+            dataflow (str): Name of the dataflow to transfer
+
+        Returns:
+            str: The ID of the transfer request
+
+
+        """
+        self._log.info(
+            f"Transferring dataflow {dataflow} from {source_dataspace} to {destination_dataspace}"  # noqa E501
+        )
+        data = {
+            "sourceDataspace": source_dataspace,
+            "destinationDataspace": destination_dataspace,
+            "sourceDataflow": dataflow,
+            "destinationDataflow": dataflow,
+            "transferContent": 0,
+            "sourceVersion": 0,
+            "targetVersion": 0,
+            "restorationOptionRequired": False,
+            "validationType": 0,
+        }
+
+        resp = httpx.post(
+            url=f"{self.TRANSFER_URL}/transfer/dataflow",
+            headers=self._keycloak_client.auth_header(),
+            data=data,
+        )
+        return resp.json().get("message").split(" ")[2]
+
+    def get_tune(self, dataspace: str, dsd_id: str):
+        """
+        Retrieve tune information for a specific DSD in a dataspace.
+
+        Args:
+            dataspace (str): The dataspace name
+            dsd_id (str): The ID of the Data Structure Definition
+
+        Returns:
+            dict: Tune information for the specified DSD
+
+        """
+        self._log.info(f"Getting DSD {dsd_id} tune information in ds {dataspace}")
+        data = {"dataspace": dataspace, "dsd": dsd_id}
+        resp = httpx.post(
+            url=f"{self.TRANSFER_URL}/tune/info",
+            headers=self._keycloak_client.auth_header(),
+            data=data,
+        )
+        return resp.json()
+
+    def set_tune(self, dataspace: str, dsd_id: str, index_type: int):
+        """
+        Set tune parameters for a specific DSD in a dataspace.
+
+        Args:
+            dataspace (str): The dataspace name
+            dsd_id (str): The ID of the Data Structure Definition
+            index_type (int): The type of index to set
+
+        Returns:
+            dict: Response containing the result of the tune operation
+
+
+        """
+        self._log.info(f"Getting DSD {dsd_id} tune information in ds {dataspace}")
+        data = {"dataspace": dataspace, "dsd": dsd_id, "indexType": index_type}
+        resp = httpx.post(
+            url=f"{self.TRANSFER_URL}/tune/dsd",
+            headers=self._keycloak_client.auth_header(),
+            data=data,
+        )
+        return resp.json()