das-cli 1.0.0__py3-none-any.whl

das/ai/plugins/dasai.py

@@ -0,0 +1,50 @@
+import os
+import logging
+from dotenv import load_dotenv
+import asyncio
+from semantic_kernel import Kernel
+from semantic_kernel.connectors.ai.open_ai import (
+    OpenAIChatCompletion,    
+)
+from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+from semantic_kernel.contents.chat_history import ChatHistory
+from semantic_kernel.connectors.ai.function_choice_behavior import FunctionChoiceBehavior
+from das.ai.plugins.entries.entries_plugin import GetEntryByCodePlugin
+from das.common.config import load_openai_api_key
+
+logger = logging.getLogger(__name__)
+load_dotenv()
+
+class DasAI:
+
+    def __init__(self):
+        self.kernel = Kernel()
+        api_key = os.getenv("OPENAI_API_KEY") or load_openai_api_key()
+        if not api_key:
+            raise ValueError("OpenAI API key is not configured.")
+        self.openai_chat_completion = OpenAIChatCompletion(ai_model_id="gpt-4o-mini", api_key=api_key)
+        self.kernel.add_service(self.openai_chat_completion)
+        self.kernel.add_plugin(GetEntryByCodePlugin(), plugin_name="get_entry_by_code")                                
+
+    async def main(self):
+        history = ChatHistory()
+        history.add_system_message("You are a laboratory assistent that helps researchers; phD students and any employee of NIOZ to find their answers in DAS (Data Archive System). Only answer questions about DAS.")
+        user_input = None
+        while user_input != "exit":
+            user_input = input("User > ")
+            history.add_user_message(user_input)
+            result = await self.openai_chat_completion.get_chat_message_content(
+                chat_history=history,
+                settings=PromptExecutionSettings(
+                    api_key=os.getenv("OPENAI_API_KEY") or load_openai_api_key(),
+                    function_choice_behavior=FunctionChoiceBehavior.Auto()
+                ),
+                kernel=self.kernel
+            )           
+            print("Assistant >",str(result))
+            history.add_message(result)
+
+
+if __name__ == "__main__":
+    ai = DasAI()    
+    asyncio.run(ai.main())

das/ai/plugins/entries/entries_plugin.py

@@ -0,0 +1,16 @@
+import logging
+from semantic_kernel.functions.kernel_function_decorator import kernel_function
+from semantic_kernel.functions.kernel_arguments import KernelArguments
+from das.managers.entries_manager import EntryManager
+
+logger = logging.getLogger(__name__)
+
+
+class GetEntryByCodePlugin:
+    def __init__(self):
+        self.entry_manager = EntryManager()
+
+    @kernel_function(name="GetEntryByCode", description="Get an entry by its code.")
+    def get_entry_by_code(self, code: str):
+        """Get the entry code based on the entry name."""	
+        return self.entry_manager.get(code=code)

das/app.py

@@ -0,0 +1,37 @@
+from das.authentication.auth import Auth
+from das.services.attributes import AttributesService
+from das.services.cache import CacheService
+from das.services.entries import EntriesService
+from das.services.entry_fields import EntryFieldsService
+from das.services.hangfire import HangfireService
+from das.services.search import SearchService
+from das.common.config import save_api_url
+
+#  $env:PYTHONPATH="C:\Workspace\das-cli"  
+
+class Das:
+    def __init__(self, base_url: str):
+        if base_url is None or base_url == "":
+            raise ValueError("You must be authenticated.")
+        save_api_url(base_url)
+        self.base_url = base_url
+        self.attributes = AttributesService(base_url)
+        self.cache = CacheService(base_url)
+        self.entries = EntriesService(base_url)
+        self.hangfire = HangfireService(base_url)
+        self.entry_fields = EntryFieldsService(base_url)
+        self.search = SearchService(base_url)        
+
+    def authenticate(self, username: str, password: str) -> str:
+        """
+        Authenticate with the DAS API and return the token.
+        
+        Args:
+            username (str): The username to authenticate with
+            password (str): The password to authenticate with
+            
+        Returns:
+            str: The authentication token or None if authentication fails
+        """
+        auth = Auth(self.base_url, username, password)
+        return auth.token

das/authentication/auth.py

@@ -0,0 +1,43 @@
+from das.common.api import post_data
+from das.common.config import save_token
+
+
+class Auth:
+    def __init__(self, base_url, username, password):
+        self.base_url = base_url
+        self.username = username
+        # Don't store password as an instance variable for security
+        self.token = None
+
+        # Pass password directly to authenticate method
+        self.authenticate(password)
+
+    def authenticate(self, password):
+        """
+        Authenticate the user and obtain an access token.
+        
+        Args:
+            password (str): The password to authenticate with
+        """
+        url = f"{self.base_url}/api/TokenAuth/Authenticate"
+        data = {
+            "userNameOrEmailAddress": self.username,
+            "password": password
+        }
+        response = post_data(url, data=data)
+        if response.get("error"):
+            print(f"Authentication failed: {response['error']}")
+        else:
+            self.token = response.get("result").get("accessToken")
+            save_token(self.token)
+            # Return silently, let the CLI handle success messages
+            return self.token
+
+if __name__ == "__main__":
+    # Example for testing authentication
+    import getpass
+    base_url = input("Base URL: ")
+    username = input("Username: ")
+    password = getpass.getpass("Password: ")
+    auth = Auth(base_url=base_url, username=username, password=password)
+    print(f"Token obtained: {bool(auth.token)}")

das/authentication/secure_input.py

@@ -0,0 +1,67 @@
+import getpass
+import keyring
+import platform
+import os
+
+# Define service name for keyring
+SERVICE_NAME = "das-cli"
+
+def get_password(username, prompt="Password: "):
+    """
+    Get password securely using the appropriate method for the platform.
+    
+    Args:
+        username (str): Username for associating with stored password
+        prompt (str): Prompt text to display when asking for password
+        
+    Returns:
+        str: The password entered by user or retrieved from keyring
+    """
+    try:
+        # Try to get password from keyring first
+        stored_pass = keyring.get_password(SERVICE_NAME, username)
+        if stored_pass:
+            return stored_pass
+    except:
+        # If keyring fails, continue to manual input
+        pass
+        
+    # Get password from user input
+    return getpass.getpass(prompt)
+
+def store_credentials(username, password):
+    """
+    Store credentials securely in the system's keyring.
+    
+    Args:
+        username (str): The username to store
+        password (str): The password to store
+        
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    try:
+        keyring.set_password(SERVICE_NAME, username, password)
+        return True
+    except Exception as e:
+        print(f"Warning: Could not store credentials securely ({e})")
+        return False
+
+def clear_stored_credentials(username):
+    """
+    Remove stored credentials from the system's keyring.
+    
+    Args:
+        username (str): The username whose credentials should be removed
+        
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    try:
+        keyring.delete_password(SERVICE_NAME, username)
+        return True
+    except keyring.errors.PasswordDeleteError:
+        # Password doesn't exist
+        return True
+    except Exception:
+        return False