sws-api-client 0.0.9.dev0__tar.gz → 1.0.0b0__tar.gz

{sws_api_client-0.0.9.dev0/sws_api_client.egg-info → sws_api_client-1.0.0b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sws_api_client
-Version: 0.0.9.dev0
+Version: 1.0.0b0
 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,7 +16,8 @@ Classifier: Operating System :: Microsoft :: Windows
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.31.0
-Requires-Dist: dataclasses>=0.6
+Requires-Dist: pydantic>=2.7.4
+Requires-Dist: python-dotenv>=0.19.0
 
 
 # SWS API Client
@@ -71,23 +72,29 @@ We need to create a conf file (default name: `"conf_sws_api_client.json"`) with
 
 ```json
 {
-    "sws_endpoint": "<sws_endpoint>",
-    "access_token": "<access_token>"
+    "sws_endpoint": "https://sws.dev.fao.org",
+    "sws_token": "XXX",
+    "current_task_id": "XXX",
+    "current_execution_id": "XXX",
+    "authclient": {
+        "clientId": "XXX",
+        "clientSecret": "XXX",
+        "tokenEndpoint": "https://fao-dev.auth.eu-west-1.amazoncognito.com/oauth2/token",
+        "scope": "sws/user"
+    }
 }
 ```
 
-And instantiate the client in our script with the class method `from_conf`:
+And instantiate the client in our script with the class method `auto`:
 
 ```python
 from sws_api_client import SwsApiClient
 
-sws_client = SwsApiClient.from_conf(conf_file="<conf_file_path>")
-
-# Or, if the conf_file is named "conf_sws_api_client.json" and is in the current working directory
-
-sws_client = SwsApiClient.from_conf()
+sws_client = SwsApiClient.auto()
 ```
 
+Behind the scene it will automatically detect the fact that you are in debug mode and it will instanciate the client using the `from_conf` method
+
 ### Instantiate the client in a SWS plugin
 
 When working withing a SWS plugin instantiate the client as:
@@ -95,13 +102,28 @@ When working withing a SWS plugin instantiate the client as:
 ```python
 from sws_api_client import SwsApiClient
 
-sws_client = SwsApiClient.from_env()
+sws_client = SwsApiClient.auto()
 ```
 
+Behind the scene it will automatically detect the fact that you are in a SWS plugin and it will instanciate the client using the `from_env` method
+
 ### Perform requests
 
 To perform requests you just need to call the available methods using the SwsApiClient object, as an example:
 
 ```python
-dataset_details = sws_client.get_dataset_export_details(dataset_id="<dataset_id>")
+datasets = Datasets(sws_client)
+dataset = datasets.get_dataset_info('aproduction')
+logger.info(f"Dataset info: {dataset}")
+```
+
+more complete examples can be found in the `example` folder:
+
+```bash
+cp example/conf_sws_api_client.json.example example/conf_sws_api_client.json
+# edit the file with your credentials
+python3 -m venv example/.venv
+source example/.venv/bin/activate
+pip install -r example/requirements
+python example/dataset_example.py
 ```

{sws_api_client-0.0.9.dev0 → sws_api_client-1.0.0b0}/README.md

@@ -50,23 +50,29 @@ We need to create a conf file (default name: `"conf_sws_api_client.json"`) with
 
 ```json
 {
-    "sws_endpoint": "<sws_endpoint>",
-    "access_token": "<access_token>"
+    "sws_endpoint": "https://sws.dev.fao.org",
+    "sws_token": "XXX",
+    "current_task_id": "XXX",
+    "current_execution_id": "XXX",
+    "authclient": {
+        "clientId": "XXX",
+        "clientSecret": "XXX",
+        "tokenEndpoint": "https://fao-dev.auth.eu-west-1.amazoncognito.com/oauth2/token",
+        "scope": "sws/user"
+    }
 }
 ```
 
-And instantiate the client in our script with the class method `from_conf`:
+And instantiate the client in our script with the class method `auto`:
 
 ```python
 from sws_api_client import SwsApiClient
 
-sws_client = SwsApiClient.from_conf(conf_file="<conf_file_path>")
-
-# Or, if the conf_file is named "conf_sws_api_client.json" and is in the current working directory
-
-sws_client = SwsApiClient.from_conf()
+sws_client = SwsApiClient.auto()
 ```
 
+Behind the scene it will automatically detect the fact that you are in debug mode and it will instanciate the client using the `from_conf` method
+
 ### Instantiate the client in a SWS plugin
 
 When working withing a SWS plugin instantiate the client as:
@@ -74,13 +80,28 @@ When working withing a SWS plugin instantiate the client as:
 ```python
 from sws_api_client import SwsApiClient
 
-sws_client = SwsApiClient.from_env()
+sws_client = SwsApiClient.auto()
 ```
 
+Behind the scene it will automatically detect the fact that you are in a SWS plugin and it will instanciate the client using the `from_env` method
+
 ### Perform requests
 
 To perform requests you just need to call the available methods using the SwsApiClient object, as an example:
 
 ```python
-dataset_details = sws_client.get_dataset_export_details(dataset_id="<dataset_id>")
+datasets = Datasets(sws_client)
+dataset = datasets.get_dataset_info('aproduction')
+logger.info(f"Dataset info: {dataset}")
+```
+
+more complete examples can be found in the `example` folder:
+
+```bash
+cp example/conf_sws_api_client.json.example example/conf_sws_api_client.json
+# edit the file with your credentials
+python3 -m venv example/.venv
+source example/.venv/bin/activate
+pip install -r example/requirements
+python example/dataset_example.py
 ```

{sws_api_client-0.0.9.dev0 → sws_api_client-1.0.0b0}/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.9-dev"
+VERSION = "1.0.0-beta"
 
 # 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","dataclasses>=0.6"],
+    install_requires=["requests>=2.31.0", "pydantic>=2.7.4", "python-dotenv>=0.19.0"],
     keywords=["python", "fao", "sws", "rest", "api", "client"],
     classifiers=[
         "Development Status :: 1 - Planning",

sws_api_client-1.0.0b0/sws_api_client/auth.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+class AuthClientCredentials(BaseModel):
+    clientId: str
+    clientSecret: str
+    scope: str
+    tokenEndpoint: str

sws_api_client-1.0.0b0/sws_api_client/datasets.py

@@ -0,0 +1,127 @@
+import logging
+from pydantic import BaseModel
+from typing import List, Optional, Dict
+from sws_api_client.sws_api_client import SwsApiClient
+logger = logging.getLogger(__name__)
+
+class Label(BaseModel):
+    en: str
+
+class Lifecycle(BaseModel):
+    state: str
+    type: str
+    previousState: Optional[str]
+    created: int
+    lastModified: int
+    lastModifiedBy: str
+
+class Domain(BaseModel):
+    id: str
+    label: Label
+    description: Dict
+
+class Binding(BaseModel):
+    joinColumn: str
+
+class Dimension(BaseModel):
+    id: str
+    label: Label
+    description: Dict
+    sdmxName: str
+    codelist: str
+    roots: List[str]
+    binding: Binding
+    checkValidityPeriod: bool
+    formulas: List
+    type: str
+
+class Dimensions(BaseModel):
+    dimensions: List[Dimension]
+
+class PivotingGrouped(BaseModel):
+    id: str
+    ascending: bool
+
+class Pivoting(BaseModel):
+    grouped: List[PivotingGrouped]
+    row: PivotingGrouped
+    cols: PivotingGrouped
+
+class DatasetBinding(BaseModel):
+    observationTable: str
+    coordinateTable: str
+    sessionObservationTable: str
+    metadataTable: str
+    metadataElementTable: str
+    sessionMetadataTable: str
+    sessionMetadataElementTable: str
+    validationTable: str
+    sessionValidationTable: str
+    tagObservationTable: str
+    tags: List
+
+class Dataset(BaseModel):
+    id: str
+    label: Label
+    description: Dict
+    sdmxName: str
+    lifecycle: Lifecycle
+    domain: Domain
+    dimensions: Dimensions
+    flags: Dict
+    rules: Dict
+    pivoting: Pivoting
+    pluginbar: Dict
+    showEmptyRows: bool
+    showRealCalc: bool
+    useApproveCycle: bool
+    binding: DatasetBinding
+
+class Fingerprint(BaseModel):
+    empty: bool
+    sessions: int
+    queries: int
+    tags: int
+    computationTags: int
+    modules: int
+
+class DataModel(BaseModel):
+    dataset: Dataset
+    fingerprint: Fingerprint
+
+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
+    
+    def get_dataset_info(self, dataset_id: str) -> DataModel:
+
+        url = f"/admin/dataset/{dataset_id}"
+
+        response = self.sws_client.discoverable.get('is_api', url)
+
+        return response
+
+    def create_dataset(self, dataset: Dataset) -> DataModel:
+
+        url = "/admin/dataset"
+
+        response = self.sws_client.discoverable.post('is_api', url, data=dataset.dict())
+
+        return response
+    
+    def clone_dataset(self, dataset_id: str, new_id: str) -> DataModel:
+
+        dataset = self.get_dataset_info(dataset_id)
+        dataset.dataset.id = new_id
+        new_dataset = self.create_dataset(dataset.dataset)
+        return new_dataset

{sws_api_client-0.0.9.dev0 → sws_api_client-1.0.0b0}/sws_api_client/discover.py

@@ -1,11 +1,27 @@
+import logging
+import os
 import requests
 
+from sws_api_client.token import Token
+
+logger = logging.getLogger(__name__)
+
 class Discover:
 
-    def __init__(self,access_token:str, discover:dict) -> None:
-        self.discover = discover
-        self.access_token = access_token
+    def __init__(self,sws_endpoint:str,sws_token:str, token:Token) -> None:
+        self.sws_endpoint = sws_endpoint
+        self.sws_token = sws_token
+        self.token = token
+        self.discover = self.__get_discover()
+        logger.debug(f"Discover initialized with endpoint {sws_endpoint} and token {sws_token}")
 
+    def __get_discover(self) -> dict:
+        token = self.token.get_token()
+        discover_endpoint = f"{self.sws_endpoint}/discover"
+        headers = {"Authorization": token.access_token, 'sws-token': self.sws_token}
+        
+        return requests.get(url=discover_endpoint, headers=headers).json()
+    
     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.")
@@ -15,7 +31,8 @@ class Discover:
         
         x_api_key = self.discover[endpoint].get("key", "")
         full_path = f"{self.discover[endpoint]['path']}{path}"
-        full_headers = {"Authorization": self.access_token}
+        token = self.token.get_token()
+        full_headers = {"Authorization": token.access_token, "sws-token": self.sws_token}
         if x_api_key:
             full_headers["x-api-key"] = x_api_key
 
@@ -29,12 +46,12 @@ class Discover:
             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}")
+            logger.error(f"HTTP Error: {errh}")
+            logger.error(f"HTTP Status Code: {errh.response.status_code}")
+            logger.error(f"Response Text: {errh.response.text}")
+            logger.error(f"Request URL: {errh.request.url}")
         except requests.exceptions.RequestException as err:
-            print(f"Request Exception: {err}")
+            logger.error(f"Request Exception: {err}")
 
         return {}
 

sws_api_client-1.0.0b0/sws_api_client/sws_api_client.py

@@ -0,0 +1,117 @@
+import argparse
+import json
+import os
+import boto3
+from typing import Optional
+from sws_api_client.auth import AuthClientCredentials
+from sws_api_client.discover import Discover
+from sws_api_client.token import Token
+import logging
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_CREDENTIALS_SECRET_NAME = "SWS_USER_CREDENTIALS_SECRET_NAME"
+
+class SwsApiClient:
+
+    def __init__(self,
+                 sws_endpoint: str,
+                 sws_token: str,
+                 authclient: AuthClientCredentials,
+                 current_task_id:Optional[str],
+                 current_execution_id:Optional[str]
+        ) -> None:
+        
+        logger.info("Initializing SwsApiClient")
+
+        self.sws_endpoint = sws_endpoint
+        self.sws_token = sws_token
+        self.authclient = authclient
+        self.current_task_id = current_task_id
+        self.current_execution_id = current_execution_id
+        self.token = Token(authclient)
+        self.is_debug = self.check_debug()
+        self.discoverable = Discover(sws_endpoint=sws_endpoint, sws_token=sws_token, token=self.token)
+        logger.debug(f"SwsApiClient initialized with endpoint {sws_endpoint} and token {sws_token}")
+
+    def __get_authclient_credentials_from_secret(self, env_name="SWS_USER_CREDENTIALS_SECRET_NAME") -> AuthClientCredentials:
+        logger.debug(f"Fetching auth client credentials from secret: {env_name}")
+        secret_name = os.getenv(env_name)
+        self.session = boto3.Session() if self.session is None else self.session
+        self.secret_manager = self.session.client('secretsmanager') if self.secret_manager is None else self.secret_manager
+        response = self.secret_manager.get_secret_value(SecretId=secret_name)
+        secretContent = json.loads(response['SecretString'])
+        logger.debug(f"Secret fetched successfully: {secretContent}")
+        return AuthClientCredentials(
+            clientId=secretContent["ID"],
+            clientSecret=secretContent["SECRET"],
+            scope=secretContent["SCOPE"],
+            tokenEndpoint=secretContent["TOKEN_ENDPOINT"]
+        )
+
+    @classmethod
+    def from_env(cls, sws_endpoint_env="SWS_ENDPOINT", authclient_secret_name=DEFAULT_CREDENTIALS_SECRET_NAME):
+        logger.debug(f"Creating SwsApiClient from environment variables: {sws_endpoint_env}, {authclient_secret_name}")
+        authclient:AuthClientCredentials = cls.__get_authclient_credentials_from_secret(env_name=authclient_secret_name)
+        return cls(
+            sws_endpoint=os.getenv(sws_endpoint_env),
+            current_task_id=os.getenv("TASK_ID"),
+            current_execution_id=os.getenv("EXECUTION_ID"),
+            authclient=authclient
+        )
+
+    @classmethod
+    def from_conf(cls, conf_file="conf_sws_api_client.json"):
+        logger.debug(f"Creating SwsApiClient from config file: {conf_file}")
+        with open(conf_file) as f:
+            kwargs = json.load(f)
+            logger.debug(f"Config loaded: {kwargs}")
+            return cls(
+                sws_endpoint=kwargs["sws_endpoint"],
+                sws_token=kwargs["sws_token"],
+                current_task_id=kwargs.get("current_task_id"),
+                current_execution_id=kwargs.get("current_execution_id"),
+                authclient=AuthClientCredentials(**kwargs["authclient"])
+            )
+
+    @classmethod
+    def from_args(cls):
+        logger.debug("Creating SwsApiClient from command line arguments")
+        parser = argparse.ArgumentParser(description="Instantiate SwsApiClient from args")
+        parser.add_argument("--sws_endpoint", type=str, required=True, help="The sws endpoint")
+        parser.add_argument("--sws_token", type=str, required=True, help="The SWS access token")
+        parser.add_argument("--authclient_id", type=str, required=True, help="The authclient ID")
+        parser.add_argument("--authclient_secret", type=str, required=True, help="The authclient secret")
+        parser.add_argument("--authclient_scope", type=str, required=True, help="The authclient scope")
+        parser.add_argument("--authclient_endpoint", type=str, required=True, help="The authclient endpoint URI")
+        parser.add_argument("--current_task_id", type=str, required=False, help="The current task ID")
+        parser.add_argument("--current_execution_id", type=str, required=False, help="The current execution ID")
+        args, _ = parser.parse_known_args()
+        props = vars(args)
+        logger.debug(f"Arguments parsed: {props}")
+        return cls(
+            sws_endpoint=props.get("sws_endpoint"),
+            current_task_id=props.get("current_task_id"),
+            current_execution_id=props.get("current_execution_id"),
+            authclient={
+                "client_id": props.get("authclient_id"),
+                "client_secret": props.get("authclient_secret"),
+                "scope": props.get("authclient_scope"),
+                "endpoint": props.get("authclient_endpoint")
+            }
+        )
+    
+    @classmethod
+    def check_debug(cls):
+        debug = os.getenv("DEBUG_MODE") == "TRUE" or os.getenv("DEBUG_MODE") is None
+        logger.debug(f"Debug mode is {'on' if debug else 'off'}")
+        return debug
+    
+    @classmethod
+    def auto(cls):
+        debug = cls.check_debug()
+        logger.debug(f"Auto-detecting client creation method, debug mode: {debug}")
+        if debug:
+            return cls.from_conf()
+        else:
+            return cls.from_env()

{sws_api_client-0.0.9.dev0 → sws_api_client-1.0.0b0}/sws_api_client/tags.py

@@ -1,7 +1,7 @@
 # task_manager.py
+import logging
 from sws_api_client.sws_api_client import SwsApiClient
-from dataclasses import dataclass
-from typing import List, Dict, Optional
+logger = logging.getLogger(__name__)
 
 class Tags:
 

{sws_api_client-0.0.9.dev0 → sws_api_client-1.0.0b0}/sws_api_client/tasks.py

@@ -1,8 +1,11 @@
+import logging
 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
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class TaskDataset:
@@ -127,7 +130,7 @@ class TaskManager:
                 user=task.get('info').get('user'),
                 outcome=task.get('info').get('outcome'),
                 status=task.get('info').get('status'),
-                group=task.get('group')
+                group=task.get('info').get('group')
             )
         )
     
@@ -177,7 +180,7 @@ class TaskManager:
                 not_created_counter = 0
             
                 task_status = task_response.info.detail_status
-                print(f"Task {task_id} status: {task_status}")
+                logger.info(f"Task {task_id} status: {task_status}")
                 if task_status == 'ENDED':
                     return task_response
 

sws_api_client-1.0.0b0/sws_api_client/token.py

@@ -0,0 +1,39 @@
+import datetime
+import logging
+import os
+from pydantic import BaseModel
+import requests
+
+logger = logging.getLogger(__name__)
+from sws_api_client.auth import AuthClientCredentials
+
+class TokenModel(BaseModel):
+    access_token: str
+    expires_on: datetime.datetime
+
+class Token:
+
+    def __init__(self,authclient:AuthClientCredentials) -> None:
+        self.authclient = authclient
+        self.token = self.get_token()
+    
+    def get_token(self) -> TokenModel:
+        if not hasattr(self, 'token') or self.token.expires_on is None or self.token.expires_on < datetime.datetime.now():
+            url = f"{self.authclient.tokenEndpoint}"
+            data = {
+                "grant_type": "client_credentials",
+                "client_id": self.authclient.clientId,
+                "client_secret": self.authclient.clientSecret,
+                "scope": self.authclient.scope,
+            }
+            response = requests.post(url, data=data)
+            response.raise_for_status()
+            result = response.json()
+            self.token = TokenModel(
+                access_token=result["access_token"],
+                expires_on=datetime.datetime.now() + datetime.timedelta(seconds=result["expires_in"])
+            )
+            logger.debug(f"Token: {self.token}")
+            return self.token
+        else:
+            return self.token

{sws_api_client-0.0.9.dev0 → sws_api_client-1.0.0b0/sws_api_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sws_api_client
-Version: 0.0.9.dev0
+Version: 1.0.0b0
 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,7 +16,8 @@ Classifier: Operating System :: Microsoft :: Windows
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.31.0
-Requires-Dist: dataclasses>=0.6
+Requires-Dist: pydantic>=2.7.4
+Requires-Dist: python-dotenv>=0.19.0
 
 
 # SWS API Client
@@ -71,23 +72,29 @@ We need to create a conf file (default name: `"conf_sws_api_client.json"`) with
 
 ```json
 {
-    "sws_endpoint": "<sws_endpoint>",
-    "access_token": "<access_token>"
+    "sws_endpoint": "https://sws.dev.fao.org",
+    "sws_token": "XXX",
+    "current_task_id": "XXX",
+    "current_execution_id": "XXX",
+    "authclient": {
+        "clientId": "XXX",
+        "clientSecret": "XXX",
+        "tokenEndpoint": "https://fao-dev.auth.eu-west-1.amazoncognito.com/oauth2/token",
+        "scope": "sws/user"
+    }
 }
 ```
 
-And instantiate the client in our script with the class method `from_conf`:
+And instantiate the client in our script with the class method `auto`:
 
 ```python
 from sws_api_client import SwsApiClient
 
-sws_client = SwsApiClient.from_conf(conf_file="<conf_file_path>")
-
-# Or, if the conf_file is named "conf_sws_api_client.json" and is in the current working directory
-
-sws_client = SwsApiClient.from_conf()
+sws_client = SwsApiClient.auto()
 ```
 
+Behind the scene it will automatically detect the fact that you are in debug mode and it will instanciate the client using the `from_conf` method
+
 ### Instantiate the client in a SWS plugin
 
 When working withing a SWS plugin instantiate the client as:
@@ -95,13 +102,28 @@ When working withing a SWS plugin instantiate the client as:
 ```python
 from sws_api_client import SwsApiClient
 
-sws_client = SwsApiClient.from_env()
+sws_client = SwsApiClient.auto()
 ```
 
+Behind the scene it will automatically detect the fact that you are in a SWS plugin and it will instanciate the client using the `from_env` method
+
 ### Perform requests
 
 To perform requests you just need to call the available methods using the SwsApiClient object, as an example:
 
 ```python
-dataset_details = sws_client.get_dataset_export_details(dataset_id="<dataset_id>")
+datasets = Datasets(sws_client)
+dataset = datasets.get_dataset_info('aproduction')
+logger.info(f"Dataset info: {dataset}")
+```
+
+more complete examples can be found in the `example` folder:
+
+```bash
+cp example/conf_sws_api_client.json.example example/conf_sws_api_client.json
+# edit the file with your credentials
+python3 -m venv example/.venv
+source example/.venv/bin/activate
+pip install -r example/requirements
+python example/dataset_example.py
 ```

{sws_api_client-0.0.9.dev0 → sws_api_client-1.0.0b0}/sws_api_client.egg-info/SOURCES.txt

@@ -2,11 +2,13 @@ LICENSE
 README.md
 setup.py
 sws_api_client/__init__.py
+sws_api_client/auth.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/token.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-1.0.0b0/sws_api_client.egg-info/requires.txt

@@ -0,0 +1,3 @@
+requests>=2.31.0
+pydantic>=2.7.4
+python-dotenv>=0.19.0

sws_api_client-0.0.9.dev0/sws_api_client/datasets.py

@@ -1,15 +0,0 @@
-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.9.dev0/sws_api_client/sws_api_client.py

@@ -1,101 +0,0 @@
-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, 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"
-        headers = {"Authorization": self.access_token}
-        return requests.get(url=discover_endpoint, headers=headers).json()
-
-    @classmethod
-    def from_env(cls, sws_endpoint_env="SWS_ENDPOINT", access_token_env="ACCESS_TOKEN"):
-        return cls(
-            sws_endpoint=os.getenv(sws_endpoint_env),
-            access_token=os.getenv(access_token_env),
-            current_task_id = os.getenv("TASK_ID"),
-            current_execution_id = os.getenv("EXECUTION_ID")
-        )
-
-    @classmethod
-    def from_conf(cls, conf_file="conf_sws_api_client.json"):
-        with open(conf_file) as f:
-            kwargs = json.load(f)
-            return cls(**kwargs)
-
-    @classmethod
-    def from_args(cls):
-        parser = argparse.ArgumentParser(
-            description="Instantiate SwsApiClient from args"
-        )
-        parser.add_argument(
-            "--sws_endpoint", type=str, required=True, help="The sws endpoint"
-        )
-        parser.add_argument(
-            "--access_token", type=str, required=True, help="The access token"
-        )
-        parser.add_argument(
-            "--current_task_id", type=str, required=False, help="The current task ID"
-        )
-        parser.add_argument(
-            "--current_execution_id", 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:
-
-        session_api_key = self.discover["session_api"]["key"]
-        session_api_path = self.discover["session_api"]["path"]
-
-        url = f"{session_api_path}/dataset/{dataset_id}/info"
-        params = {"extended": "true"}
-        headers = {"Authorization": self.access_token, "x-api-key": session_api_key}
-
-        response = requests.get(url, params=params, headers=headers).json()
-
-        return response
-
-    def get_read_access_url(self, path: str, expiration: int) -> dict:
-
-        tag_api_key = self.discover["tag_api"]["key"]
-        tag_api_path = self.discover["tag_api"]["path"]
-
-        url = f"{tag_api_path}/tags/dissemination/getReadAccessUrl"
-        body = {"path": path, "expiration": expiration}
-        headers = {"Authorization": self.access_token, "x-api-key": tag_api_key}
-
-        response = requests.post(url, json=body, headers=headers).json()
-
-        return response

sws_api_client-0.0.9.dev0/sws_api_client.egg-info/requires.txt

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