das-cli 1.0.0__py3-none-any.whl

das/common/api.py

@@ -0,0 +1,100 @@
+import json
+import requests
+from das.common.config import VERIFY_SSL
+
+
+def get_data(url, headers=None, params=None):
+    """
+    Fetch data from a REST API endpoint.
+
+    Args:
+        url (str): The API endpoint URL.
+        headers (dict, optional): Headers to include in the request.
+        params (dict, optional): Query parameters for the request.
+
+    Returns:
+        dict: The JSON response from the API or an error message.
+    """
+    try:
+        response = requests.get(url, headers=headers, params=params, verify=VERIFY_SSL)
+        response.raise_for_status()  # Raise an error for HTTP errors
+        try:
+            return response.json()
+        except json.JSONDecodeError as json_err:
+            print(f"Error decoding JSON response: {json_err}")
+            return {"error": f"Invalid JSON response: {json_err}", "raw_content": response.text[:200]}
+    except requests.RequestException as e:
+        print(f"Error fetching API data: {e}")
+        return {"error": str(e)}
+
+def post_data(url, headers=None, data=None):
+    """
+    Send data to a REST API endpoint.
+
+    Args:
+        url (str): The API endpoint URL.
+        headers (dict, optional): Headers to include in the request.
+        data (dict, optional): The data to send in the request body.
+
+    Returns:
+        dict: The JSON response from the API or an error message.
+    """
+    try:
+        response = requests.post(url, headers=headers, json=data, verify=VERIFY_SSL)
+        response.raise_for_status()  # Raise an error for HTTP errors
+        try:
+            return response.json()
+        except json.JSONDecodeError as json_err:
+            print(f"Error decoding JSON response: {json_err}")
+            return {"error": f"Invalid JSON response: {json_err}", "raw_content": response.text[:200]}
+    except requests.RequestException as e:
+        print(f"Error posting API data: {e}")
+        return {"error": str(e)}
+    
+def put_data(url, headers=None, data=None):
+    """
+    Update data at a REST API endpoint.
+
+    Args:
+        url (str): The API endpoint URL.
+        headers (dict, optional): Headers to include in the request.
+        data (dict, optional): The data to send in the request body.
+
+    Returns:
+        dict: The JSON response from the API or an error message.
+    """
+    try:
+        response = requests.put(url, headers=headers, json=data, verify=VERIFY_SSL)
+        response.raise_for_status()  # Raise an error for HTTP errors
+        try:
+            return response.json()
+        except json.JSONDecodeError as json_err:
+            print(f"Error decoding JSON response: {json_err}")
+            return {"error": f"Invalid JSON response: {json_err}", "raw_content": response.text[:200]}
+    except requests.RequestException as e:
+        print(f"Error updating API data: {e}")
+        return {"error": str(e)}    
+    
+def delete_data(url, headers=None, data=None):
+    """
+    Delete data from a REST API endpoint.
+
+    Args:
+        url (str): The API endpoint URL.
+        headers (dict, optional): Headers to include in the request.
+        data (dict, optional): The data to send in the request body.
+
+    Returns:
+        dict: The JSON response from the API or an error message.
+    """
+    try:
+        response = requests.delete(url, headers=headers, json=data, verify=VERIFY_SSL)
+        response.raise_for_status()  # Raise an error for HTTP errors
+        try:
+            return response.json()
+        except json.JSONDecodeError as json_err:
+            print(f"Error decoding JSON response: {json_err}")
+            return {"error": f"Invalid JSON response: {json_err}", "raw_content": response.text[:200]}
+    except requests.RequestException as e:
+        print(f"Error deleting API data: {e}")
+        return {"error": str(e)}

das/common/config.py

@@ -0,0 +1,185 @@
+import json
+import os
+from pathlib import Path
+from typing import Optional
+import logging
+
+# Set up logging
+logging.basicConfig(
+    level=logging.WARNING,  # Only show warnings and errors by default
+    format='%(message)s'    # Simplified format for cleaner output
+)
+
+# ---------- Config ----------
+
+SERVICE_NAME = "Data-Archive-System"
+DEFAULT_BASE_URL = "https://localhost:44301"  # ← change to your API
+VERIFY_SSL = True  # Default is True for secure connections
+TOKEN_FIELD = "accessToken"
+
+def _config_dir() -> Path:
+    if os.name == "nt":  # Windows
+         base = Path(os.getenv("APPDATA", Path.home()))
+    else:  # macOS and Linux
+        base = Path(os.getenv("XDG_CONFIG_HOME", Path.home() / ".config"))
+    d = Path(base) / SERVICE_NAME
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+CONFIG_FILE = _config_dir() / "config.json"
+
+def save_api_url(api_url: str) -> None:
+    config = {}
+    if CONFIG_FILE.exists():
+        try:
+            config = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+        except Exception:
+            config = {}
+    config["api_url"] = api_url
+    CONFIG_FILE.write_text(json.dumps(config), encoding="utf-8")
+
+def load_api_url() -> Optional[str]:
+    if CONFIG_FILE.exists():
+        try:
+            return json.loads(CONFIG_FILE.read_text(encoding="utf-8")).get("api_url")
+        except Exception:
+            return None
+    return None
+
+def save_verify_ssl(verify: bool) -> None:
+    """
+    Save the VERIFY_SSL setting to the config file.
+    
+    Args:
+        verify (bool): Whether to verify SSL certificates.
+    """
+    global VERIFY_SSL
+    config = {}
+    if CONFIG_FILE.exists():
+        try:
+            config = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+        except Exception:
+            config = {}
+    config["verify_ssl"] = verify
+    VERIFY_SSL = verify
+    CONFIG_FILE.write_text(json.dumps(config), encoding="utf-8")
+
+def load_verify_ssl() -> bool:
+    """
+    Load the VERIFY_SSL setting from the config file.
+    
+    Returns:
+        bool: The VERIFY_SSL setting, defaults to True if not found.
+    """
+    global VERIFY_SSL
+    if CONFIG_FILE.exists():
+        try:
+            config = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+            verify = config.get("verify_ssl")
+            if verify is not None:
+                VERIFY_SSL = verify
+                return verify
+        except Exception:
+            pass
+    return VERIFY_SSL
+
+def _config_dir() -> Path:
+    if os.name == "nt":  # Windows
+         base = Path(os.getenv("APPDATA", Path.home()))
+    else:  # macOS and Linux
+        base = Path(os.getenv("XDG_CONFIG_HOME", Path.home() / ".config"))
+    d = Path(base) / SERVICE_NAME
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+def _token_path() -> Path:
+    return _config_dir() / "token.json"
+
+def _openai_key_path() -> Path:
+    return _config_dir() / "openai_key.json"
+
+
+def _keyring_available() -> bool:
+    try:
+        import keyring  # noqa: F401
+        return True
+    except Exception:
+        return False
+    
+def save_token(token: str) -> None:
+    if _keyring_available():
+        import keyring
+        keyring.set_password(SERVICE_NAME, "default", token)
+    else:
+        p = _token_path()
+        p.write_text(json.dumps({"token": token}), encoding="utf-8")
+        if os.name != "nt":
+            os.chmod(p, 0o600)    
+
+def load_token() -> Optional[str]:
+    if _keyring_available():
+        import keyring
+        return keyring.get_password(SERVICE_NAME, "default")
+    p = _token_path()
+    if p.exists():
+        try:
+            return json.loads(p.read_text(encoding="utf-8")).get("token")
+        except Exception:
+            return None
+    return None            
+
+def clear_token() -> None:
+    if _keyring_available():
+        import keyring
+        try:
+            keyring.delete_password(SERVICE_NAME, "default")
+        except Exception:
+            pass
+    try:
+        _token_path().unlink()
+    except FileNotFoundError:
+        pass
+
+# ---------- OpenAI API Key management ----------
+
+def save_openai_api_key(api_key: str) -> None:
+    """Persist the OpenAI API key securely (keyring if available, else protected file)."""
+    if _keyring_available():
+        import keyring
+        keyring.set_password(SERVICE_NAME, "openai_api_key", api_key)
+    else:
+        p = _openai_key_path()
+        p.write_text(json.dumps({"api_key": api_key}), encoding="utf-8")
+        if os.name != "nt":
+            os.chmod(p, 0o600)
+
+def load_openai_api_key() -> Optional[str]:
+    """Retrieve the stored OpenAI API key, if present."""
+    if _keyring_available():
+        import keyring
+        val = keyring.get_password(SERVICE_NAME, "openai_api_key")
+        if val:
+            return val
+    p = _openai_key_path()
+    if p.exists():
+        try:
+            return json.loads(p.read_text(encoding="utf-8")).get("api_key")
+        except Exception:
+            return None
+    return None
+
+def clear_openai_api_key() -> None:
+    """Remove any stored OpenAI API key from secure storage and file fallback."""
+    if _keyring_available():
+        import keyring
+        try:
+            keyring.delete_password(SERVICE_NAME, "openai_api_key")
+        except Exception:
+            pass
+    try:
+        _openai_key_path().unlink()
+    except FileNotFoundError:
+        pass
+
+# Initialize VERIFY_SSL from config file if available
+load_verify_ssl()

das/common/entry_fields_constants.py

@@ -0,0 +1,3 @@
+# Constants for Entry Fields - Input Types
+DIGITAL_OBJECT_INPUT = 13
+SELECT_COMBO_INPUT = 4

das/common/enums.py

@@ -0,0 +1,46 @@
+from enum import IntEnum
+
+class DownloadRequestStatus(IntEnum):
+    NONE = 0
+    # When a user starts their download request.
+    ENQUEUED = 1
+    # Download approval requested from the digital object's owner.
+    APPROVAL_REQUESTED = 2
+    # Waiting for approval from the owner to download the requested files.
+    WAITING_FOR_APPROVAL = 3
+    # All files in the current request were approved (if applicable).
+    APPROVED = 4
+    # The download request was not authorized by the owner(s).
+    DECLINED = 5
+    # Approved requests will be prepared to be delivered.
+    HANDLE_FILES_TO_BE_DELIVERED = 6
+    # Status while the set of files are being compacted.
+    COMPACTING_BUNDLE = 7
+    # The download request is completed and ready to be downloaded.
+    COMPLETED = 8
+    # Incomplete request: not all files are available to download.
+    INCOMPLETE = 9
+    # Request is invalid or cannot be processed due to missing/invalid data.
+    FAILED = 10
+
+class DownloadRequestItemStatus(IntEnum):
+    # Digital Object download request was enqueued.
+    ENQUEUED = 1
+    # Download approval requested from the digital object's owner.
+    APPROVAL_REQUESTED = 2
+    # Waiting for approval by the digital object owner.
+    WAITING_FOR_APPROVAL = 3
+    # Download of the digital object was approved by its owner.
+    APPROVED = 4
+    # Download of the digital object was denied by its owner.
+    DECLINED = 5
+    # Notification of decline has been sent.
+    DECLINED_NOTIFICATION_SENT = 6
+    # Waiting to be downloaded.
+    WAITING_TO_BE_DOWNLOADED = 7
+    # In process.
+    IN_PROCESS = 8
+    # File is ready to be delivered.
+    AVAILABLE_TO_DOWNLOAD = 9
+    # Internal error occurred.
+    ERROR = 10    

das/common/file_utils.py

@@ -0,0 +1,203 @@
+"""
+File utility functions for importing data from various formats
+"""
+
+import json
+import csv
+import os
+from pathlib import Path
+from typing import Dict, Any, List, Union
+
+def load_json_file(file_path: str) -> Union[List[Dict[str, Any]], Dict[str, Any]]:
+    """
+    Load data from a JSON file.
+    Can load either a single entry (dictionary) or multiple entries (list of dictionaries).
+    
+    Args:
+        file_path (str): Path to the JSON file
+        
+    Returns:
+        Union[List[Dict[str, Any]], Dict[str, Any]]: The loaded JSON data
+        
+    Raises:
+        ValueError: If the file doesn't exist or isn't a valid JSON file
+    """
+    file_path = Path(file_path)
+    
+    if not file_path.exists():
+        raise ValueError(f"File not found: {file_path}")
+    
+    if file_path.suffix.lower() != '.json':
+        raise ValueError(f"Not a JSON file: {file_path}")
+    
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            return data
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Invalid JSON file: {e}")
+
+def load_csv_file(file_path: str) -> List[Dict[str, Any]]:
+    """
+    Load data from a CSV file.
+    Assumes the first row contains headers and subsequent rows contain values.
+    Creates a list of dictionaries, one for each row in the CSV file.
+    
+    Args:
+        file_path (str): Path to the CSV file
+        
+    Returns:
+        List[Dict[str, Any]]: A list of dictionaries, each representing one row from the CSV
+        
+    Raises:
+        ValueError: If the file doesn't exist or isn't a valid CSV file
+    """
+    file_path = Path(file_path)
+    
+    if not file_path.exists():
+        raise ValueError(f"File not found: {file_path}")
+    
+    if file_path.suffix.lower() != '.csv':
+        raise ValueError(f"Not a CSV file: {file_path}")
+    
+    try:
+        with open(file_path, 'r', encoding='utf-8', newline='') as f:
+            reader = csv.reader(f)
+            headers = next(reader, None)
+            
+            if not headers:
+                raise ValueError("CSV file is empty or has no headers")
+            
+            result = []
+            for row in reader:
+                if not row:  # Skip empty rows
+                    continue
+                    
+                # Create a dictionary for this row
+                entry = {}
+                for i, header in enumerate(headers):
+                    if i < len(row):
+                        entry[header] = row[i]
+                    else:
+                        entry[header] = ""  # Empty value for missing columns
+                
+                result.append(entry)
+            
+            if not result:
+                raise ValueError("CSV file has headers but no data rows")
+                
+            return result
+    except csv.Error as e:
+        raise ValueError(f"CSV parsing error: {e}")
+    except UnicodeDecodeError:
+        raise ValueError("Unable to decode CSV file, ensure it's saved with UTF-8 encoding")
+
+def load_excel_file(file_path: str) -> List[Dict[str, Any]]:
+    """
+    Load data from an Excel file.
+    Assumes the first row contains headers and subsequent rows contain values.
+    Creates a list of dictionaries, one for each row in the Excel file.
+    
+    Args:
+        file_path (str): Path to the Excel file
+        
+    Returns:
+        List[Dict[str, Any]]: A list of dictionaries, each representing one row from the Excel file
+        
+    Raises:
+        ValueError: If the file doesn't exist, isn't a valid Excel file, or pandas is not installed
+    """
+    file_path = Path(file_path)
+    
+    if not file_path.exists():
+        raise ValueError(f"File not found: {file_path}")
+    
+    if file_path.suffix.lower() not in ['.xls', '.xlsx']:
+        raise ValueError(f"Not an Excel file: {file_path}")
+    
+    # Try to import pandas here to avoid making it a required dependency
+    try:
+        import pandas as pd
+    except ImportError:
+        raise ValueError("pandas is required to read Excel files. Install it with: pip install pandas openpyxl")
+    
+    try:
+        df = pd.read_excel(file_path)
+        
+        if df.empty:
+            raise ValueError("Excel file is empty")
+        
+        # Convert all rows to dictionaries
+        result = []
+        for _, row in df.iterrows():
+            row_dict = {}
+            for key, value in row.items():
+                if pd.isna(value):
+                    row_dict[key] = ""
+                else:
+                    row_dict[key] = value
+            result.append(row_dict)
+                
+        return result
+    except Exception as e:
+        raise ValueError(f"Excel parsing error: {e}")
+
+def parse_data_string(data_string: str) -> Union[List[Dict[str, Any]], Dict[str, Any]]:
+    """
+    Parse a data string in the format "{ 'key1': value1, 'key2': value2, ... }"
+    or a list of such objects "[{ 'key1': value1, ... }, { 'key2': value2, ... }]"
+    
+    Args:
+        data_string (str): The data string to parse
+        
+    Returns:
+        Union[List[Dict[str, Any]], Dict[str, Any]]: The parsed data
+        
+    Raises:
+        ValueError: If the string cannot be parsed
+    """
+    try:
+        # Clean up the input string to make it valid JSON
+        # Replace single quotes with double quotes
+        data_string = data_string.replace("'", '"')
+        
+        # Handle Yes/No values (convert to true/false for JSON)
+        data_string = data_string.replace(': Yes', ': true').replace(': No', ': false')
+        
+        # Add quotes around unquoted keys
+        import re
+        data_string = re.sub(r'(\{|\,)\s*([a-zA-Z0-9_]+)\s*:', r'\1 "\2":', data_string)
+        
+        # Parse the resulting JSON
+        return json.loads(data_string)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Invalid data string format: {e}")
+
+def load_file_based_on_extension(file_path: str) -> Union[List[Dict[str, Any]], Dict[str, Any]]:
+    """
+    Load data from a file based on its extension.
+    
+    Args:
+        file_path (str): Path to the file
+        
+    Returns:
+        Union[List[Dict[str, Any]], Dict[str, Any]]: The loaded data - either a single entry or a list of entries
+        
+    Raises:
+        ValueError: If the file type is not supported
+    """
+    file_path = Path(file_path)
+    
+    if not file_path.exists():
+        raise ValueError(f"File not found: {file_path}")
+    
+    suffix = file_path.suffix.lower()
+    
+    if suffix == '.json':
+        return load_json_file(file_path)
+    elif suffix == '.csv':
+        return load_csv_file(file_path)
+    elif suffix in ['.xls', '.xlsx']:
+        return load_excel_file(file_path)
+    else:
+        raise ValueError(f"Unsupported file type: {suffix}. Supported types are: .json, .csv, .xls, .xlsx")

das/managers/download_manager.py

@@ -0,0 +1,93 @@
+import json
+import time
+from das.common.config import load_api_url
+from das.services.downloads import DownloadRequestService
+from das.services.entries import EntriesService
+
+
+class DownloadManager:
+
+    def __init__(self):
+        base_url = load_api_url()
+
+        if (base_url is None or base_url == ""):
+            raise ValueError(f"Base URL is required - {self.__class__.__name__}")
+
+        self.download_request_service = DownloadRequestService(base_url)
+        self.entry_service = EntriesService(base_url)
+
+    def create_download_request(self, request_data: dict):
+        """
+        Create a new download request.
+
+        Args:
+            request_data (dict): A dictionary where keys are entry codes and values are lists of codes of the files. Also includes a 'name' key for the download request name.
+        """
+
+        requests = {
+            'items': []
+        }
+
+        if 'name' not in request_data or not request_data['name']:
+            request_data['name'] = f"Download Request at {time.strftime('%Y-%m-%d %H:%M:%S')}"
+
+        erros = []
+
+        for entry_code in request_data.keys():
+            # Validate that the entry exists
+            if entry_code == 'name':
+                continue
+            response = self.entry_service.get_entry(code=entry_code)
+            if response.get('entry', None) is None:
+                erros.append(f"Entry with code '{entry_code}' does not exist.")
+            else:
+                attribute_id = response.get('attributeId', None)
+                digital_objects_json = response.get('entry').get('6', None)  # Assuming '6' is the attribute ID for digital objects
+                if digital_objects_json is None:
+                    erros.append(f"Entry with code '{entry_code}' has no digital objects.")
+                    continue
+
+                # convert digital_objects_json to a array of dicts
+                digital_objects = []
+                try:
+                    digital_objects = json.loads(digital_objects_json)
+                except Exception as e:
+                    erros.append(f"Error parsing digital objects for entry '{entry_code}': {str(e)}")
+                    continue
+
+                entry = response.get('entry')
+
+                if request_data[entry_code] is None or len(request_data[entry_code]) == 0:
+                    filtered_digital_objects = digital_objects
+                else:
+                    filtered_digital_objects = [obj for obj in digital_objects if obj.get('code') in request_data[entry_code]]
+
+                if len(filtered_digital_objects) == 0:
+                    erros.append(f"No matching digital objects found for entry '{entry_code}' with the provided file codes.")
+                    continue
+                for digital_object in filtered_digital_objects:
+                    request = {
+                        'name': request_data['name'],
+                        'sourceId': entry.get('id'),
+                        'sourceAttributeId': attribute_id,
+                        'id': digital_object.get('id')
+                    }
+                    requests['items'].append(request)
+
+        if erros:
+            return {"errors": erros}
+
+        return self.download_request_service.create(requests)
+    
+    def delete_download_request(self, request_id: str):
+        """
+        Delete a download request by ID.
+
+        Args:
+            request_id (str): The ID of the download request to delete.
+        """
+        return self.download_request_service.delete(request_id)
+
+    def get_my_requests(self):
+        """Get all download requests for the current user."""
+        return self.download_request_service.get_my_requests()