perd 0.0.1__py3-none-any.whl

perd/__init__.py

@@ -0,0 +1,26 @@
+"""PER Datasets - A module for loading reservoir datasets."""
+
+__version__ = "0.0.1"
+
+from .talkaholic.reservoir import Reservoir
+from .reservoir import load_random, load
+from .utils.init import initialize
+from .workflow import workflow, WorkflowStreamInput, WorkflowStreamOutput
+from . import utils
+from .visual import Visualizer
+
+# Instantiate the visualizer as a singleton object for generic access.
+visual = Visualizer()
+
+__all__ = [
+    "load_random",
+    "load",
+    "Reservoir",
+    "__version__",
+    "initialize",
+    "workflow",
+    "WorkflowStreamInput",
+    "WorkflowStreamOutput",
+    "visual",
+    "utils",
+]

perd/cli.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+"""
+Command-line interface for managing perd API keys
+"""
+
+import os
+import json
+import sys
+import argparse
+import getpass
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+def get_config_file() -> Path:
+    """Get the path to the configuration file"""
+    # Use user's home directory for cross-platform compatibility
+    home = Path.home()
+    config_dir = home / ".per_datasets"
+    config_dir.mkdir(exist_ok=True)
+    return config_dir / "config.json"
+
+def load_config() -> Dict[str, Any]:
+    """Load configuration from file"""
+    config_file = get_config_file()
+    if config_file.exists():
+        try:
+            with open(config_file, 'r') as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {}
+    return {}
+
+def save_config(config: Dict[str, Any]) -> bool:
+    """Save configuration to file"""
+    config_file = get_config_file()
+    try:
+        with open(config_file, 'w') as f:
+            json.dump(config, f, indent=2)
+        return True
+    except IOError:
+        return False
+
+def set_api_key(api_key: str) -> bool:
+    """Set the global API key"""
+    config = load_config()
+    config['api_key'] = api_key.strip()
+    
+    if save_config(config):
+        print("✅ API key stored successfully!")
+        print(f"🔑 API Key: pk...{api_key[-4:] if len(api_key) > 4 else api_key}")
+        return True
+    else:
+        print("❌ Failed to save API key")
+        return False
+
+def get_api_key() -> Optional[str]:
+    """Get the stored API key"""
+    config = load_config()
+    return config.get('api_key')
+
+
+def remove_api_key() -> bool:
+    """Remove the stored API key"""
+    config = load_config()
+    if 'api_key' in config:
+        del config['api_key']
+        if save_config(config):
+            print("✅ API key removed successfully!")
+            return True
+        else:
+            print("❌ Failed to remove API key")
+            return False
+    else:
+        print("⚠️  No API key found to remove")
+        return False
+
+def show_status() -> None:
+    """Show current configuration status"""
+    config = load_config()
+    
+    if 'api_key' in config:
+        api_key = config['api_key']
+        print("🔑 API Key Status: CONFIGURED")
+        print(f"   Key: pk...{api_key[-4:] if len(api_key) > 4 else api_key}")
+        print(f"   Config File: {get_config_file()}")
+        
+        # Test the API key
+        try:
+            import requests
+            headers = {'X-API-Key': api_key}
+            response = requests.get('https://perd-server.onrender.com/datasets', headers=headers, timeout=5)
+            if response.status_code == 200:
+                print("🌐 API Status: ACTIVE")
+            else:
+                print(f"🌐 API Status: INACTIVE (HTTP {response.status_code})")
+        except Exception as e:
+            print(f"🌐 API Status: ERROR ({type(e).__name__})")
+    else:
+        print("🔑 API Key Status: NOT CONFIGURED")
+        print(f"   Config File: {get_config_file()}")
+        print("   Use 'perd set-key <api_key>' to configure")
+
+def clear_config() -> bool:
+    """Clear all configuration"""
+    config_file = get_config_file()
+    if config_file.exists():
+        try:
+            config_file.unlink()
+            print("✅ Configuration cleared successfully!")
+            return True
+        except IOError:
+            print("❌ Failed to clear configuration")
+            return False
+    else:
+        print("⚠️  No configuration found to clear")
+        return False
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Manage perd API keys globally",
+        prog="perd"
+    )
+    
+    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+    
+    # Set API key command
+    set_parser = subparsers.add_parser('set-key', help='Set the API key')
+    set_parser.add_argument('api_key', help='Your API key')
+    
+    # Get API key command
+    get_parser = subparsers.add_parser('get-key', help='Get the stored API key')
+    
+    # Remove API key command
+    remove_parser = subparsers.add_parser('remove-key', help='Remove the API key')
+    
+    # Status command
+    status_parser = subparsers.add_parser('status', help='Show configuration status')
+    
+    # Clear command
+    clear_parser = subparsers.add_parser('clear', help='Clear all configuration')
+    
+    # Interactive mode
+    interactive_parser = subparsers.add_parser('interactive', help='Interactive setup')
+    
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        return
+    
+    if args.command == 'set-key':
+        set_api_key(args.api_key)
+    
+    elif args.command == 'get-key':
+        api_key = get_api_key()
+        if api_key:
+            print(f"pk...{api_key[-4:] if len(api_key) > 4 else api_key}")
+        else:
+            print("No API key configured")
+    
+    elif args.command == 'remove-key':
+        remove_api_key()
+    
+    elif args.command == 'status':
+        show_status()
+    
+    elif args.command == 'clear':
+        clear_config()
+    
+    elif args.command == 'interactive':
+        print("🔧 Interactive API Key Setup")
+        print("=" * 40)
+        
+        # Check if key already exists
+        existing_key = get_api_key()
+        if existing_key:
+            print(f"Current API key: pk...{existing_key[-4:] if len(existing_key) > 4 else existing_key}")
+            response = input("Do you want to replace it? (y/N): ").strip().lower()
+            if response != 'y':
+                print("Setup cancelled")
+                return
+        
+        # Get new API key
+        print("\nEnter your API key:")
+        api_key = getpass.getpass("API Key: ").strip()
+        
+        if not api_key:
+            print("❌ API key cannot be empty")
+            return
+        
+        # Save configuration
+        if set_api_key(api_key):
+            print("\n🎉 Setup complete!")
+            print("You can now use perd in any project without specifying the API key.")
+
+if __name__ == "__main__":
+    main()

perd/reservoir/__init__.py

@@ -0,0 +1,9 @@
+"""
+Reservoir module for per_datasets
+"""
+
+from .load_random import load_random
+from .load import load
+from ..talkaholic.reservoir import Reservoir
+
+__all__ = ['load_random', 'load', 'Reservoir']

perd/reservoir/load.py

@@ -0,0 +1,67 @@
+"""
+load function for the reservoir module
+"""
+
+import json
+import requests
+import pandas as pd
+from typing import Dict, Any, List, Union, Optional
+from pathlib import Path
+
+from ..talkaholic.reservoir import Reservoir
+from ..utils.config import load_stored_api_key
+from ..utils.display import digital_screen
+from ..utils.api import get_api_config, get_headers, make_request
+
+
+def load(reservoir_id: str) -> pd.DataFrame:
+    """
+    ## load(reservoir id)
+    
+    Loads a specific reservoir model by ID from the reservoir datasets in the database.
+    
+    Args:
+        reservoir_id (str): The ID of the reservoir to load
+        
+    ### **returns**
+    
+    [`pandas.DataFrame`]
+        A DataFrame containing all rows of the reservoir dataset
+        
+    Raises:
+        RuntimeError: If the module hasn't been initialized
+        ValueError: If the reservoir ID is invalid or not found
+    """
+    try:
+        headers = get_headers()
+        _API_CONFIG = get_api_config()
+        url = f"{_API_CONFIG['base_url']}/datasets/{reservoir_id}"
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()
+        api_data = response.json()
+        
+        # Handle the actual API response structure
+        if 'data' in api_data and 'columns' in api_data:
+            data = api_data['data']
+            columns = api_data['columns']
+            returned_reservoir_id = api_data.get('dataset_id', reservoir_id)
+            
+            if len(data) == 0:
+                raise ValueError("API returned reservoir with no data")
+            
+            # Convert all rows to a DataFrame
+            df = pd.DataFrame(data)
+            
+            # Return the DataFrame with all rows
+            return df
+        else:
+            raise ValueError("API response does not contain 'data' and 'columns' fields")
+        
+    except requests.exceptions.RequestException as e:
+        raise ConnectionError(f"Failed to connect to API endpoint: {e}")
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Invalid JSON response from API: {e}")
+    except Exception as e:
+        if "not initialized" in str(e):
+            raise e
+        raise RuntimeError(f"Error loading reservoir {reservoir_id}: {e}")

perd/reservoir/load_random.py

@@ -0,0 +1,45 @@
+"""load_random function for the reservoir module."""
+
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+from ..utils.api import make_request
+
+
+def load_random(
+    filters: Optional[Dict[str, Any]] = None,
+    fields: Optional[List[str]] = None,
+    partitions: Optional[List[str]] = None,
+) -> pd.DataFrame:
+    """
+    Load a random reservoir model from the reservoir datasets in the database.
+
+    Args:
+        filters: Optional query filters.
+        fields: Optional selected fields.
+        partitions: Optional partition dimensions.
+
+    Returns:
+        pandas.DataFrame: DataFrame containing all rows from the selected dataset.
+    """
+    try:
+        api_data = make_request(filters=filters, fields=fields, partitions=partitions)
+
+        if "data" in api_data and "columns" in api_data:
+            data = api_data["data"]
+            dataset_id = api_data.get("dataset_id", "Unknown")
+
+            if len(data) == 0:
+                raise ValueError("API returned dataset with no data")
+
+            df = pd.DataFrame(data)
+            print(f"Loaded dataset with ID: {dataset_id}")
+            return df
+
+        raise ValueError("API response does not contain 'data' and 'columns' fields")
+
+    except Exception as e:
+        if "not initialized" in str(e):
+            raise e
+        raise RuntimeError(f"Error loading reservoir data: {e}")

perd/talkaholic/__init__.py

@@ -0,0 +1,7 @@
+"""
+Talkaholic submodule for reservoir datasets
+"""
+
+from .reservoir import Reservoir
+
+__all__ = ['Reservoir']

perd/talkaholic/reservoir.py

@@ -0,0 +1,52 @@
+"""
+Reservoir class for the talkaholic submodule
+"""
+
+from typing import Dict, Any
+import pandas as pd
+
+
+class Reservoir:
+    """
+    A class representing a reservoir dataset that behaves like a pandas DataFrame
+    """
+    
+    def __init__(self, data: Dict[str, Any]):
+        """
+        Initialize a Reservoir object with the given data
+        
+        Args:
+            data: Dictionary containing reservoir parameters
+        """
+        self.data = data
+        # Create a DataFrame internally for pandas-like behavior
+        self._df = pd.DataFrame([data]) if data else pd.DataFrame()
+    
+    def __repr__(self):
+        return f"Reservoir({self.data})"
+    
+    @property
+    def shape(self):
+        """Return the shape of the reservoir data (rows, columns)"""
+        return self._df.shape
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the reservoir data back to a dictionary"""
+        return self.data
+    
+    def to_dataframe(self) -> pd.DataFrame:
+        """Convert the reservoir data to a pandas DataFrame"""
+        return self._df.copy()
+    
+    def get_field(self, field_name: str, default: Any = None) -> Any:
+        """
+        Get any field from the original data with a default value
+        
+        Args:
+            field_name: Name of the field to retrieve
+            default: Default value if field doesn't exist
+            
+        Returns:
+            The field value or default
+        """
+        return self.data.get(field_name, default)

perd/utils/__init__.py

@@ -0,0 +1,21 @@
+"""Utils module for per_datasets."""
+
+from .config import get_config_file, load_stored_api_key
+from .display import digital_screen
+from .api import get_headers, make_request, get_api_config, set_api_key
+from .init import initialize
+from . import names
+from . import units
+
+__all__ = [
+    "get_config_file",
+    "load_stored_api_key",
+    "digital_screen",
+    "get_headers",
+    "make_request",
+    "get_api_config",
+    "set_api_key",
+    "initialize",
+    "names",
+    "units",
+]