sws-api-client 0.0.2__tar.gz → 0.0.3.dev1__tar.gz

{sws_api_client-0.0.2/sws_api_client.egg-info → sws_api_client-0.0.3.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sws_api_client
-Version: 0.0.2
+Version: 0.0.3.dev1
 Summary: A Python client to easily interact with the FAO SWS REST APIs
 Home-page: https://bitbucket.org/cioapps/sws-it-python-api-client/src/main/
 Author: Mansillo, Daniele (CSI)
@@ -16,6 +16,7 @@ Classifier: Operating System :: Microsoft :: Windows
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.31.0
+Requires-Dist: dataclasses>=0.6
 
 
 # SWS API Client

{sws_api_client-0.0.2 → sws_api_client-0.0.3.dev1}/setup.py

@@ -7,7 +7,7 @@ here = os.path.abspath(os.path.dirname(__file__))
 with open(os.path.join(here, "README.md"), encoding="utf-8") as fh:
     long_description = "\n" + fh.read()
 
-VERSION = "0.0.2"
+VERSION = "0.0.3-dev1"
 
 # Setting up
 setup(
@@ -19,7 +19,7 @@ setup(
     long_description_content_type="text/markdown",
     long_description=long_description,
     packages=find_packages(),
-    install_requires=["requests>=2.31.0"],
+    install_requires=["requests>=2.31.0","dataclasses>=0.6"],
     keywords=["python", "fao", "sws", "rest", "api", "client"],
     classifiers=[
         "Development Status :: 1 - Planning",

sws_api_client-0.0.3.dev1/sws_api_client/__init__.py

@@ -0,0 +1,11 @@
+from .sws_api_client import SwsApiClient
+from .discover import Discover
+from .datasets import Datasets
+from .tasks import (
+    TaskManager,
+    PluginPayload,
+    TaskDataset,
+    TaskInfo,
+    TaskResponse
+)
+from .tags import Tags

sws_api_client-0.0.3.dev1/sws_api_client/datasets.py

@@ -0,0 +1,15 @@
+from sws_api_client.sws_api_client import SwsApiClient
+
+class Datasets:
+
+    def __init__(self, sws_client: SwsApiClient) -> None:
+        self.sws_client = sws_client
+
+    def get_dataset_export_details(self, dataset_id: str) -> dict:
+
+        url = f"/dataset/{dataset_id}/info"
+        params = {"extended": "true"}
+
+        response = self.sws_client.discoverable.get('session_api', url, params=params)
+
+        return response

sws_api_client-0.0.3.dev1/sws_api_client/discover.py

@@ -0,0 +1,51 @@
+import requests
+
+class Discover:
+
+    def __init__(self,access_token:str, discover:dict) -> None:
+        self.discover = discover
+        self.access_token = access_token
+
+    def call(self, method: str, endpoint: str, path: str, params: dict = None, headers: dict = None, data: dict = None) -> dict:
+        if not endpoint:
+            raise ValueError("An endpoint must be provided.")
+
+        if endpoint not in self.discover or 'path' not in self.discover[endpoint]:
+            raise ValueError(f"endpoint '{endpoint}' not found")
+        
+        x_api_key = self.discover[endpoint].get("key", "")
+        full_path = f"{self.discover[endpoint]['path']}{path}"
+        full_headers = {"Authorization": self.access_token}
+        if x_api_key:
+            full_headers["x-api-key"] = x_api_key
+
+        if headers:
+            full_headers.update(headers)
+
+        request_func = getattr(requests, method.lower())
+        response = request_func(full_path, params=params, headers=full_headers, json=data)
+
+        try:
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError as errh:
+            print(f"HTTP Error: {errh}")
+            print(f"HTTP Status Code: {errh.response.status_code}")
+            print(f"Response Text: {errh.response.text}")
+            print(f"Request URL: {errh.request.url}")
+        except requests.exceptions.RequestException as err:
+            print(f"Request Exception: {err}")
+
+        return {}
+
+    def get(self, endpoint, path: str, params: dict = None, headers: dict = None) -> dict:
+        return self.call("GET", endpoint, path, params=params, headers=headers)
+
+    def post(self, endpoint, path: str, data: dict = None, params: dict = None, headers: dict = None) -> dict:
+        return self.call("POST", endpoint, path, params=params, headers=headers, data=data)
+
+    def put(self, endpoint, path: str, data: dict = None, params: dict = None, headers: dict = None) -> dict:
+        return self.call("PUT", endpoint, path, params=params, headers=headers, data=data)
+
+    def delete(self, endpoint, path: str, params: dict = None, headers: dict = None) -> dict:
+        return self.call("DELETE", endpoint, path, params=params, headers=headers)

{sws_api_client-0.0.2 → sws_api_client-0.0.3.dev1}/sws_api_client/sws_api_client.py

@@ -2,15 +2,22 @@ import argparse
 import json
 import os
 
+from typing import Optional
+
 import requests
 
+from sws_api_client.discover import Discover
 
 class SwsApiClient:
 
-    def __init__(self, sws_endpoint: str, access_token: str) -> None:
+    def __init__(self, sws_endpoint: str, access_token: str, current_task_id:Optional[str], current_execution_id:Optional[str] ) -> None:
         self.sws_endpoint = sws_endpoint
         self.access_token = access_token
+        self.current_task_id = current_task_id
+        self.current_execution_id = current_execution_id
         self.discover = self.__get_discover()
+        self.is_debug = self.check_debug()
+        self.discoverable = Discover(self.access_token, self.discover)
 
     def __get_discover(self) -> dict:
         discover_endpoint = f"{self.sws_endpoint}/discover?v=2"
@@ -22,6 +29,8 @@ class SwsApiClient:
         return cls(
             sws_endpoint=os.getenv(sws_endpoint_env),
             access_token=os.getenv(access_token_env),
+            currentTaskId = os.getenv("TASK_ID"),
+            currentExecutionId = os.getenv("EXECUTION_ID")
         )
 
     @classmethod
@@ -41,10 +50,29 @@ class SwsApiClient:
         parser.add_argument(
             "--access_token", type=str, required=True, help="The access token"
         )
+        parser.add_argument(
+            "--currentTaskId", type=str, required=False, help="The current task ID"
+        )
+        parser.add_argument(
+            "--currentExecutionId", type=str, required=False, help="The current execution ID"
+        )
 
         args, _ = parser.parse_known_args()
 
         return cls(**vars(args))
+    
+    @classmethod
+    def check_debug(self):
+        return os.getenv("DEBUG_MODE") == "TRUE" or os.getenv("DEBUG_MODE") is None
+    
+    @classmethod
+    def auto(cls):
+        debug = cls.check_debug()
+        if debug:
+            return cls.from_conf()
+        else:
+            return cls.from_env()
+
 
     def get_dataset_export_details(self, dataset_id: str) -> dict:
 

sws_api_client-0.0.3.dev1/sws_api_client/tags.py

@@ -0,0 +1,19 @@
+# task_manager.py
+from sws_api_client.sws_api_client import SwsApiClient
+from dataclasses import dataclass
+from typing import List, Dict, Optional
+
+class Tags:
+
+    def __init__(self, sws_client: SwsApiClient, endpoint: str = 'tag_api') -> None:
+        self.sws_client = sws_client
+        self.endpoint = endpoint
+
+    def get_read_access_url(self, path: str, expiration: int) -> dict:
+
+        url = f"/tags/dissemination/getReadAccessUrl"
+        body = {"path": path, "expiration": expiration}
+
+        response = self.sws_client.discoverable.post(self.endpoint, url, data=body)
+
+        return response

sws_api_client-0.0.3.dev1/sws_api_client/tasks.py

@@ -0,0 +1,160 @@
+from sws_api_client.sws_api_client import SwsApiClient
+from dataclasses import (dataclass, asdict)
+from typing import List, Dict, Optional, Literal
+import json
+import time
+
+@dataclass
+class TaskDataset:
+    domain: str
+    dataset: str
+
+@dataclass
+class PluginPayload:
+    datasets: List[TaskDataset]
+    parameters: Dict
+
+    def to_dict(self) -> Dict:
+        return asdict(self)
+
+# Define Status and DetailStatus as Literal types
+Status = Literal['ACTIVE', 'ARCHIVED']
+DetailStatus = Literal['CREATED', 'EXECUTION_PREPARED', 'EXECUTION_PROCESSING', 'EXECUTION_PROCESSED', 'STOP_REQUESTED', 'RETRIED', 'ENDED', 'ARCHIVED']
+Outcome = Literal['SUCCESS', 'FAILURE']
+@dataclass
+class TaskInfo:
+    detail_status: DetailStatus
+    ended_on: Optional[str]
+    description: str
+    updated_on: str
+    created_on: str
+    service_user: str
+    tags: Dict[str, str]
+    output: Dict
+    input: Dict
+    task_type: str
+    context: str
+    progress: int
+    user: str
+    outcome: Outcome
+    group: Optional[str]
+    status: Status
+
+@dataclass
+class TaskResponse:
+    task_id: str
+    info: TaskInfo
+
+class TaskManager:
+
+    def __init__(self, sws_client: SwsApiClient, endpoint: str = 'task_manager_api') -> None:
+        self.sws_client = sws_client
+        self.endpoint = endpoint
+
+    def update_current(self, progress: Optional[int] = None):
+        if not self.sws_client.current_task_id:
+            raise ValueError("A current task ID must be provided.")
+        if not self.sws_client.current_execution_id:
+            raise ValueError("A current task ID must be provided.")
+        taskId = self.sws_client.current_task_id
+        executionId = self.sws_client.current_execution_id
+
+        path = f'/task/{taskId}/execution/{executionId}/status'
+        data = {
+            'progress': progress
+        }
+        self.sws_client.discoverable.put(self.endpoint, path, data=data)
+
+    def create_plugin_task(self,
+            pluginId:str,
+            slow:bool,
+            payload: PluginPayload,
+            description: Optional[str],
+            group: Optional[str] = None,
+            parentTaskId: Optional[str] = None,
+            user:Optional[str] = None
+        ) -> TaskResponse:
+        
+        path = 'task/create'
+
+        data = {
+            "user": user,
+            "context": "IS",
+            "type": "RUN_PLUGIN",
+            "description": f"Run plugin {pluginId}" if description is None else description,
+            "input":{
+                "slow": slow,
+                "pluginId": pluginId,
+                "payload": payload.to_dict()
+            },
+            "config": {
+                "repeatable":True
+            },
+            "parentTaskId": parentTaskId
+        }
+
+        if group:
+            data['group'] = group
+
+        response = self.sws_client.discoverable.post(self.endpoint, path, data=data)
+        if response:
+            return self.get_task_response(response)
+        else:
+            return None
+
+    def get_task_response(self, task: Dict) -> TaskResponse:
+        return TaskResponse(
+            task_id=task['taskId'],
+            info=TaskInfo(
+                detail_status=task['info'].get('detailStatus'),
+                ended_on=task['info'].get('endedOn'),
+                description=task['info'].get('description'),
+                updated_on=task['info'].get('updatedOn'),
+                created_on=task['info'].get('createdOn'),
+                service_user=task['info'].get('serviceUser'),
+                tags=task['info'].get('tags'),
+                output=task['info'].get('output'),
+                input=json.loads(task['info'].get('input', '{}')),  # Default to an empty dictionary if 'input' is missing
+                task_type=task['info'].get('taskType'),
+                context=task['info'].get('context'),
+                progress=task['info'].get('progress'),
+                user=task['info'].get('user'),
+                outcome=task['info'].get('outcome'),
+                status=task['info'].get('status'),
+                group=task['info'].get('group')
+            )
+        )
+
+
+    def get_task(self, task_id: str) -> Optional[TaskResponse]:
+        path = f'/task/{task_id}'
+        response = self.sws_client.discoverable.get(self.endpoint, path)
+
+        if response:
+            return self.get_task_response(response)
+        else:
+            return None
+    
+    def wait_completion(self, task_id: str, poll_interval: int = 10) -> TaskResponse:
+        """
+        Wait for a task to reach the 'ENDED' status and return the task outcome.
+
+        Args:
+            task_id (str): The ID of the task.
+            poll_interval (int, optional): The interval (in seconds) between status checks. Defaults to 10.
+
+        Returns:
+            str: The final outcome of the task.
+        """
+        while True:
+            task_response = self.get_task(task_id)
+
+            if not task_response:
+                raise ValueError(f"Task with ID {task_id} not found.")
+
+            task_status = task_response.info.detail_status
+            print(f"Task {task_id} status: {task_status}")
+            if task_status == 'ENDED':
+                return task_response
+
+            time.sleep(poll_interval)

{sws_api_client-0.0.2 → sws_api_client-0.0.3.dev1/sws_api_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sws_api_client
-Version: 0.0.2
+Version: 0.0.3.dev1
 Summary: A Python client to easily interact with the FAO SWS REST APIs
 Home-page: https://bitbucket.org/cioapps/sws-it-python-api-client/src/main/
 Author: Mansillo, Daniele (CSI)
@@ -16,6 +16,7 @@ Classifier: Operating System :: Microsoft :: Windows
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.31.0
+Requires-Dist: dataclasses>=0.6
 
 
 # SWS API Client

{sws_api_client-0.0.2 → sws_api_client-0.0.3.dev1}/sws_api_client.egg-info/SOURCES.txt

@@ -2,7 +2,11 @@ LICENSE
 README.md
 setup.py
 sws_api_client/__init__.py
+sws_api_client/datasets.py
+sws_api_client/discover.py
 sws_api_client/sws_api_client.py
+sws_api_client/tags.py
+sws_api_client/tasks.py
 sws_api_client.egg-info/PKG-INFO
 sws_api_client.egg-info/SOURCES.txt
 sws_api_client.egg-info/dependency_links.txt

{sws_api_client-0.0.2 → sws_api_client-0.0.3.dev1}/sws_api_client.egg-info/requires.txt

@@ -1 +1,2 @@
 requests>=2.31.0
+dataclasses>=0.6

sws_api_client-0.0.2/sws_api_client/__init__.py

@@ -1 +0,0 @@
-from .sws_api_client import SwsApiClient