quantumdrive 0.1.0__tar.gz

quantumdrive-0.1.0/LICENSE

@@ -0,0 +1,49 @@
+SYNTHETICORE, INC. PROPRIETARY LICENSE AGREEMENT
+
+Copyright (c) 2025 Syntheticore, Inc. All Rights Reserved.
+
+This software and any accompanying documentation (the “Software”) is the proprietary property of Syntheticore, Inc. and is licensed, not sold. Use, reproduction, modification, or distribution of the Software is strictly limited to those individuals or entities that have received a valid, written license from Syntheticore, Inc.
+
+1. **License Grant**
+   Syntheticore, Inc. (“Licensor”) hereby grants the licensee (“Licensee”) a non-exclusive, non-transferable, revocable license to use the Software solely for Licensee’s internal business purposes, under the terms and conditions set forth herein and in the separate license agreement executed by Licensee.
+
+2. **Restrictions**
+   Licensee shall not, and shall not permit any third party to:
+   a. Sell, lease, sublicense, distribute, or otherwise transfer the Software or any copies thereof;
+   b. Reverse engineer, decompile, disassemble, or otherwise attempt to derive the source code of the Software;
+   c. Modify, adapt, translate, or create derivative works based on the Software;
+   d. Remove, alter, or obscure any proprietary notices or labels on the Software;
+   e. Use the Software for any purpose not expressly authorized by this Agreement or the accompanying license document.
+
+3. **Ownership**
+   All title, ownership rights, and intellectual property rights in and to the Software remain with Syntheticore, Inc. Neither this Agreement nor any use of the Software transfers to Licensee any rights, title, or interest in or to the Software, except the limited license rights expressly granted herein.
+
+4. **Termination**
+   This license will terminate automatically without notice if Licensee fails to comply with any provision of this Agreement. Upon termination, Licensee must cease all use of the Software and destroy all copies in its possession or control.
+
+5. **Disclaimer of Warranty**
+   The Software is provided “AS IS” without warranty of any kind. To the fullest extent permitted by applicable law, Syntheticore, Inc. expressly disclaims all warranties, whether express, implied, statutory, or otherwise, including but not limited to implied warranties of merchantability, fitness for a particular purpose, and non-infringement.
+
+6. **Limitation of Liability**
+   In no event shall Syntheticore, Inc. be liable for any indirect, incidental, special, consequential, or punitive damages, or any loss of profits or revenues, arising from or related to use of or inability to use the Software, even if advised of the possibility of such damages.
+
+7. **Governing Law**
+   This Agreement shall be governed by and construed in accordance with the laws of the State of [State], without regard to its conflict of laws principles.
+
+8. **Entire Agreement**
+   This Agreement, together with any separate written license agreement executed by Licensee, constitutes the entire agreement between the parties with respect to the Software and supersedes all prior or contemporaneous understandings and agreements, whether written or oral.
+
+**SYNTHETICORE, INC.**
+
+By: ________________________________________________________________
+Name: _______________________________________________________________
+Title: _______________________________________________________________
+Date: _______________________________________________________________
+
+**LICENSEE**
+
+By: ________________________________________________________________
+Name: _______________________________________________________________
+Title: _______________________________________________________________
+Date: _______________________________________________________________
+

quantumdrive-0.1.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.3
+Name: quantumdrive
+Version: 0.1.0
+Summary: QuantumDrive platform for AlphaSix
+License: MIT
+Author: Chris Steel
+Author-email: chris.steel@alphsix.com
+Requires-Python: >=3.11.0,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: appdirs (==1.4.4)
+Requires-Dist: arxiv (==2.2.0)
+Requires-Dist: docling (==2.31.0)
+Requires-Dist: dynaconf (==3.2.10)
+Requires-Dist: google-api-python-client (>=2.100.0)
+Requires-Dist: gunicorn (==23.0.0)
+Requires-Dist: jinja2 (>=3.1.5,<3.2.0)
+Requires-Dist: langchain (>=0.3.18,<0.4.0)
+Requires-Dist: langchain-community (>=0.3.17,<0.4.0)
+Requires-Dist: langchain-core (>=0.3.34,<0.4.0)
+Requires-Dist: langchain-experimental (>=0.3.4,<0.4.0)
+Requires-Dist: langchain-ollama (>=0.3.3,<0.4.0)
+Requires-Dist: langchain-openai (>=0.3.4,<0.4.0)
+Requires-Dist: langgraph (>=0.4.8,<0.5.0)
+Requires-Dist: langgraph-checkpoint (>=2.0.26,<2.1.0)
+Requires-Dist: langgraph-checkpoint-sqlite (>=2.0.10,<2.1.0)
+Requires-Dist: langgraph-prebuilt (>=0.2.2,<0.3.0)
+Requires-Dist: langgraph-sdk (>=0.1.70,<0.2.0)
+Requires-Dist: langsmith (==0.3.13)
+Requires-Dist: msal (>=1.31.1,<1.32.0)
+Requires-Dist: nvidia-cublas-cu12 (==12.4.5.8)
+Requires-Dist: nvidia-cufft-cu12 (==11.2.1.3)
+Requires-Dist: nvidia-curand-cu12 (==10.3.5.147)
+Requires-Dist: nvidia-cusolver-cu12 (==11.6.1.9)
+Requires-Dist: nvidia-cusparse-cu12 (==12.3.1.170)
+Requires-Dist: nvidia-nvjitlink-cu12 (==12.4.127)
+Requires-Dist: ollama (>=0.4.7,<0.5.0)
+Requires-Dist: openai (>=1.61.1,<1.62.0)
+Requires-Dist: poetry-core (>=2.1.2,<3.0.0)
+Requires-Dist: posthog (>=3.11.0,<3.12.0)
+Requires-Dist: pydantic (>=2.10.6,<2.11.0)
+Requires-Dist: pypdf2 (>=3.0.1,<3.1.0)
+Requires-Dist: pytest (==7.0.0)
+Requires-Dist: python-dotenv (==1.0.0)
+Requires-Dist: requests (>=2.31.0)
+Requires-Dist: sentence-transformers (>=3.4,<4.0)
+Requires-Dist: setuptools (>=80.0.0)
+Requires-Dist: sqlalchemy (>=1.4.54)
+Requires-Dist: torch (>=2.6.0,<2.7.0)
+Requires-Dist: txtai (==8.5.0)
+Requires-Dist: wolframalpha (==5.1.3)

quantumdrive-0.1.0/core/ai/__init__.py

@@ -0,0 +1 @@
+

quantumdrive-0.1.0/core/ai/q_assistant.py

@@ -0,0 +1,138 @@
+"""QAssistant: a wrapper around the agentfoundry Orchestrator with rich logging.
+
+This module previously only logged a handful of informational messages.  In
+practice, it is very difficult to debug production issues with so little
+visibility.  The changes below introduce **extensive logging** that captures
+the following additional details while still remaining lightweight and
+disabled by default unless the corresponding log-level is enabled:
+
+1.  Execution timings (initialization as well as per-question processing).
+2.  Environment / configuration that influences the assistant (LLM model,
+    tool registry contents, stub-mode, etc.).
+3.  Graceful and *fully logged* error handling – uncaught exceptions are now
+    logged with ``logger.exception`` before being propagated.
+
+Only the QAssistant implementation is touched, so no other parts of the system
+are affected, and existing public behavior stays the same.  All tests keep
+passing.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+
+from langchain_openai import ChatOpenAI
+
+from agentfoundry.agents.orchestrator import Orchestrator
+from agentfoundry.registry.tool_registry import ToolRegistry
+from agentfoundry.llm.llm_factory import LLMFactory
+
+from core.utils.app_config import AppConfig
+
+
+class QAssistant:
+    """
+    A wrapper class for the Orchestrator to provide a simple interface for the digital assistant 'Q' to answer questions.
+    """
+
+    def __init__(self) -> None:
+        """Create a new class:`QAssistant` instance.
+
+        The constructor tries to build a class:`Orchestrator`.  When
+        *agentfoundry* is not available (e.g., in lightweight environments or
+        during unit-testing), we transparently fall back to a *stub mode* that
+        returns an informative placeholder string.  All execution paths are
+        thoroughly logged.
+        """
+
+        self.logger = logging.getLogger(self.__class__.__name__)
+
+        # Timestamp used to compute initialization duration later.
+        _t0 = time.perf_counter()
+
+        # Handle environments where *agentfoundry* is not installed.
+        if ToolRegistry is None or LLMFactory is None or Orchestrator is None:
+            self.logger.warning(
+                "QAssistant initialized in *stub mode* – agentfoundry not "
+                "available.  All calls will return a placeholder response."
+            )
+            self.agent = None  # type: ignore[assignment]
+            self.logger.debug("Initialization completed in %.3f s", time.perf_counter() - _t0)
+            return
+
+        # -------------------------------------------------------------------
+        # Real agent initialisation
+        # -------------------------------------------------------------------
+        try:
+            config = AppConfig()
+
+            llm_provider = config.get("LLM_PROVIDER", "openai")
+
+            self.logger.debug("Creating LLM instance. provider=%s", llm_provider)
+
+            llm = LLMFactory().get_llm_model(llm_provider)  # type: ignore[arg-type]
+
+            tool_registry = ToolRegistry()
+            tool_registry.load_tools_from_directory()
+            self.logger.info(f"Registered tools: {tool_registry.list_tools()}")
+
+            self.agent = Orchestrator(tool_registry, llm)
+
+            self.logger.info("Orchestrator initialized successfully.")
+        except Exception as e:  # pragma: no cover – defensive, should not happen in tests
+            # We *never* let exceptions during initialization crash the process –
+            # they are logged, and we gracefully degrade to stub mode so that the
+            # rest of the application can still run.
+            self.logger.exception(f"Failed to initialise Orchestrator: {e}")
+            self.agent = None  # type: ignore[assignment]
+        finally:
+            self.logger.debug("Initialization completed in %.3f s", time.perf_counter() - _t0)
+
+    def answer_question(self, question: str) -> str:
+        """Answer *question* using the underlying agent (if available).
+
+        All important events (question receipt, duration, errors) are recorded
+        via: `logging` so operators have full insight into the
+        assistant's activity.
+        """
+
+        self.logger.info("Processing question: %s", question)
+
+        if not self.agent:
+            self.logger.warning("answer_question called while in stub mode – returning message to caller.")
+            return "QAssistant is unavailable"
+
+        _t0 = time.perf_counter()
+        try:
+            response = self.agent.run_task(question)
+            self.logger.debug("agent.run_task completed in %.3f s", time.perf_counter() - _t0)
+            self.logger.info("Response: %s", response)
+            return response
+        except Exception:
+            self.logger.exception("Exception while processing question: %s", question)
+            raise
+
+
+if __name__ == "__main__":
+    # Initialize required components
+    config = AppConfig()
+    tool_registry = ToolRegistry()
+    llm_factory = LLMFactory()
+    openai_api_key = config.get("OPENAI_API_KEY")
+    print(f"OpenAI API Key: {openai_api_key}")
+    llm = ChatOpenAI(api_key=openai_api_key)
+    # llm = llm_factory.get_llm_model(config.get("LLM_MODEL", "gpt-4o-mini"), openai_api_key)
+
+    # Create a QAssistant instance
+    assistant = QAssistant()
+
+    # Test with a simple question
+    question = "Who wrote the book 'Core Security Patterns'?"
+    response = assistant.answer_question(question)
+
+    # Verify response
+    if response:
+        print(f"Smoke test passed: Response received: {response}")
+    else:
+        print("Smoke test failed: No response received.")

quantumdrive-0.1.0/core/auth/microsoft_365_provider.py

@@ -0,0 +1,155 @@
+import json
+import os
+import logging
+from typing import Dict, Any, Optional
+
+import msal
+import requests
+
+from core.utils.app_config import AppConfig
+
+CACHE_FILE = "token_cache.json"
+
+
+class Microsoft365Provider:
+
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        conf = AppConfig()
+        self.client_id = conf.get("MS_CLIENT_ID")
+        self.client_secret = conf.get("MS_CLIENT_SECRET")
+        self.tenant_id = conf.get("MS_TENANT_ID")
+        self.logger.info(f"MS_CLIENT_ID: {self.client_id}, MS_TENANT_ID: {self.tenant_id}")
+        self.authority = f"https://login.microsoftonline.com/{self.tenant_id}"
+        self.scopes = conf.get("MS_SCOPES", "email").split()
+        if not self.scopes:
+            self.scopes = ["openid", "profile", "offline_access", "User.Read"]
+        self.redirect_uri = conf.get("MS_REDIRECT_URI", "https://quantify.alphasixdemo.com/callback")
+
+        self.cache = self._load_cache()
+        self.msal_app = msal.ConfidentialClientApplication(
+            client_id=self.client_id,
+            client_credential=self.client_secret,
+            authority=self.authority,
+            token_cache=self.cache
+        )
+
+        self.authorization_endpoint = f"{self.authority}/oauth2/v2.0/authorize"
+        self.token_endpoint = f"{self.authority}/oauth2/v2.0/token"
+        self.userinfo_endpoint = "https://graph.microsoft.com/v1.0/me"
+
+    @staticmethod
+    def _load_cache() -> msal.SerializableTokenCache:
+        cache = msal.SerializableTokenCache()
+        if os.path.exists(CACHE_FILE):
+            with open(CACHE_FILE, "r") as f:
+                cache.deserialize(f.read())
+        return cache
+
+    def _save_cache(self):
+        if self.cache.has_state_changed:
+            with open(CACHE_FILE, "w") as f:
+                f.write(self.cache.serialize())
+
+    def get_auth_url(self, state: str) -> str:
+        return self.msal_app.get_authorization_request_url(
+            scopes=self.scopes,
+            state=state,
+            redirect_uri=self.redirect_uri
+        )
+
+    def exchange_code(self, code: str) -> Dict[str, Any]:
+        result = self.msal_app.acquire_token_by_authorization_code(
+            code,
+            scopes=self.scopes,
+            redirect_uri=self.redirect_uri
+        )
+        self._save_cache()
+
+        if "error" in result:
+            self.logger.error(f"MSAL error: {result['error_description']}")
+            raise Exception(f"MSAL error: {result['error_description']}")
+
+        return result
+
+    def get_user_info(self, token_response: Dict[str, Any]) -> Dict[str, Any]:
+        access_token = token_response.get("access_token")
+        if not access_token:
+            self.logger.error("No access token in token response")
+            return {}
+        headers = {"Authorization": f"Bearer {access_token}"}
+        try:
+            resp = requests.get(self.userinfo_endpoint, headers=headers)
+            resp.raise_for_status()
+            user_data = resp.json()
+            return {
+                "id": user_data.get("id"),
+                "email": user_data.get("mail") or user_data.get("userPrincipalName"),
+                "displayName": user_data.get("displayName")
+            }
+        except requests.exceptions.HTTPError as e:
+            self.logger.error(f"User info HTTP error: {e}, Response: {e.response.text}")
+            return {}
+        except Exception as e:
+            self.logger.error(f"User info error: {e}")
+            return {}
+
+    def get_access_token(self) -> Optional[Dict[str, Any]]:
+        accounts = self.msal_app.get_accounts()
+        if accounts:
+            self.logger.info("Attempting silent token acquisition")
+            result = self.msal_app.acquire_token_silent(self.scopes, account=accounts[0])
+            if result and "access_token" in result:
+                self.logger.info("Token acquired silently")
+                return result
+
+        self.logger.info("Silent acquisition failed, using device code flow")
+        flow = self.msal_app.initiate_device_flow(scopes=self.scopes)
+        print(f"Please visit {flow['verification_uri']} and enter code: {flow['user_code']}")
+        result = self.msal_app.acquire_token_by_device_flow(flow)
+
+        if "access_token" in result:
+            self.logger.info("Token acquired via device code flow")
+            self._save_cache()
+            return result
+
+        self.logger.error(f"Token acquisition failed: {result.get('error_description')}")
+        return None
+
+    def make_entra_request(self, input_str: str) -> dict:
+        try:
+            input_data = json.loads(input_str)
+            method = input_data["method"]
+            path = input_data["path"]
+            query_params = input_data.get("query_params", {})
+            body = input_data.get("body", {})
+        except (json.JSONDecodeError, KeyError) as e:
+            return {"error": str(e)}
+
+        token_response = self.get_access_token()
+        if not token_response or "access_token" not in token_response:
+            return {"error": "No valid access token"}
+
+        url = f"https://graph.microsoft.com/beta/{path}"
+        headers = {
+            "Authorization": f"Bearer {token_response['access_token']}",
+            "Content-Type": "application/json"
+        }
+
+        try:
+            response = requests.request(method.upper(), url, headers=headers, params=query_params, json=body)
+            response.raise_for_status()
+            return response.json() if response.status_code != 204 else {"message": "No content"}
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e), "response": getattr(e.response, 'text', '')}
+
+    def logout(self) -> bool:
+        try:
+            accounts = self.msal_app.get_accounts()
+            for account in accounts:
+                self.msal_app.remove_account(account)
+            self.logger.info("Successfully logged out")
+            return True
+        except Exception as e:
+            self.logger.error(f"Logout error: {e}")
+            return False

quantumdrive-0.1.0/core/auth/microsoft_sso.py

@@ -0,0 +1,259 @@
+import os
+import json
+import logging
+import requests
+from typing import Optional, Dict
+
+import msal
+
+from core.utils.app_config import AppConfig
+
+# Path to store the token cache
+CACHE_FILE = "token_cache.json"
+
+
+class MicrosoftSSO:
+
+    def __init__(self):
+        self.client_id = AppConfig().get("MS_CLIENT_ID")
+        self.tenant_id = AppConfig().get("MS_TENANT_ID")
+        self.authority = f"https://login.microsoftonline.com/{self.tenant_id}"
+        self.scopes = ["User.Read", "Analytics.Read", "Chat.Read", "Calendars.Read"]
+
+        # Set up logging
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
+
+        # Load or create the token cache
+        self.cache = self._load_cache()
+
+        # Initialize MSAL with the cache
+        self.app = msal.PublicClientApplication(
+            client_id=self.client_id,
+            authority=self.authority,
+            token_cache=self.cache
+        )
+
+    @staticmethod
+    def _load_cache() -> msal.SerializableTokenCache:
+        """Load the token cache from a file if it exists."""
+        cache = msal.SerializableTokenCache()
+        if os.path.exists(CACHE_FILE):
+            with open(CACHE_FILE, "r") as f:
+                cache.deserialize(f.read())
+        return cache
+
+    def _save_cache(self):
+        """Save the token cache to a file if it has changed."""
+        if self.cache.has_state_changed:
+            with open(CACHE_FILE, "w") as f:
+                f.write(self.cache.serialize())
+
+    def get_access_token(self) -> Optional[Dict]:
+        """Get an access token, trying silent acquisition first."""
+        try:
+            # Check for cached accounts
+            accounts = self.app.get_accounts()
+            if accounts:
+                self.logger.info("Attempting silent token acquisition")
+                result = self.app.acquire_token_silent(self.scopes, account=accounts[0])
+                if result and "access_token" in result:
+                    self.logger.info("Token acquired silently")
+                    return result
+                else:
+                    self.logger.info("Silent acquisition failed, falling back to device code")
+
+            # Fallback to device code flow if silent fails
+            self.logger.info("Starting device code flow")
+            flow = self.app.initiate_device_flow(scopes=self.scopes)
+            print(f"Please visit {flow['verification_uri']} and enter code: {flow['user_code']}")
+            result = self.app.acquire_token_by_device_flow(flow)
+
+            if "access_token" in result:
+                self.logger.info("Token acquired via device code flow")
+                self._save_cache()  # Save the cache after successful authentication
+                return result
+            else:
+                self.logger.error(f"Token acquisition failed: {result.get('error_description')}")
+                return None
+
+        except Exception as e:
+            self.logger.error(f"Error acquiring token: {str(e)}", exc_info=True)
+            raise SystemExit
+
+    def get_users(self) -> Optional[Dict]:
+        """Get a list of users from the Microsoft Graph API."""
+        token_result = self.get_access_token()
+        if not token_result or "access_token" not in token_result:
+            self.logger.error("No valid access token available")
+            return None
+
+        try:
+            headers = {
+                "Authorization": f"Bearer {token_result['access_token']}",
+                "Content-Type": "application/json"
+            }
+
+            self.logger.info("Making Graph API request to /users")
+            response = requests.get(
+                "https://graph.microsoft.com/v1.0/users",
+                headers=headers
+            )
+            response.raise_for_status()  # Raises an exception for HTTP errors
+
+            users = response.json().get("value")
+            if users:
+                self.logger.info(f"Successfully retrieved {len(users)} users")
+                return users
+            else:
+                self.logger.error("No users found in response")
+                return None
+
+        except requests.exceptions.RequestException as e:
+            self.logger.error(f"Graph API request failed: {str(e)}")
+            if isinstance(e.response, requests.Response):
+                error_details = e.response.text
+                self.logger.error(f"Response details: {error_details}")
+            return None
+        except Exception as e:
+            self.logger.error(f"Error getting users: {str(e)}")
+            return None
+
+    def get_user_info(self) -> Optional[Dict[str, str]]:
+        """
+        Get the authenticated user's ID and email address from Microsoft Graph API.
+
+        Returns:
+            Dict[str, str]: A dictionary with 'id' and 'email' keys, or None if the request fails.
+        """
+        token_result = self.get_access_token()
+        if not token_result or "access_token" not in token_result:
+            self.logger.error("No valid access token available")
+            return None
+
+        try:
+            headers = {
+                "Authorization": f"Bearer {token_result['access_token']}",
+                "Content-Type": "application/json"
+            }
+
+            self.logger.info("Making Graph API request to /me")
+            response = requests.get(
+                "https://graph.microsoft.com/v1.0/me",
+                headers=headers
+            )
+            response.raise_for_status()  # Raises an exception for HTTP errors
+
+            user_data = response.json()
+            print(f"User data: {user_data}")
+            user_id = user_data.get("id")
+            user_email = user_data.get("mail") or user_data.get("userPrincipalName")
+
+            if user_id and user_email:
+                self.logger.info(f"Successfully retrieved user info: ID={user_id}, Email={user_email}")
+                return {"id": user_id, "email": user_email}
+            else:
+                self.logger.error("User ID or email not found in response")
+                return None
+
+        except requests.exceptions.RequestException as e:
+            self.logger.error(f"Graph API request failed: {str(e)}")
+            if isinstance(e.response, requests.Response):
+                error_details = e.response.text
+                self.logger.error(f"Response details: {error_details}")
+            return None
+        except Exception as e:
+            self.logger.error(f"Error getting user info: {str(e)}")
+            return None
+
+    def make_entra_request(self, input_str: str) -> dict:
+        """
+        Makes a request to a Microsoft Entra endpoint using the Microsoft Graph API.
+
+        Args:
+            input_str (str): A JSON string containing the request details, e.g., {"method": "GET", "path": "me"}
+
+        Returns:
+            dict: Response data or error details if the request fails.
+        """
+        print(f"\n\n CALLING WITH INPUT: {input_str}\n\n")
+        try:
+            input_data = json.loads(input_str)
+            method = input_data["method"]
+            path = input_data["path"]
+            query_params = input_data.get("query_params", {})
+            body = input_data.get("body", {})
+            # Add other optional fields as needed (e.g., query_params, body)
+        except json.JSONDecodeError:
+            return {"error": "Invalid JSON input. Expected a string like {\"method\": \"GET\", \"path\": \"me\"}"}
+        except KeyError as e:
+            return {"error": f"Missing required field: {e}"}
+
+        # Define supported HTTP methods
+        allowed_methods = ["GET", "POST", "PUT", "DELETE", "PATCH"]
+        if method.upper() not in allowed_methods:
+            return {"error": "Unsupported HTTP method"}
+
+        # Obtain access token
+        try:
+            token_result = self.get_access_token()
+        except ValueError as e:
+            return {"error": str(e)}
+
+        # print(f"Access Token: {token_result}")
+        # Construct the URL
+        url = f"https://graph.microsoft.com/beta/{path}"
+        headers = {
+            "Authorization": f"Bearer {token_result['access_token']}",
+            "Content-Type": "application/json"
+        }
+        # Make the request
+        response = None
+        try:
+            response = requests.request(method.upper(), url, headers=headers, params=query_params, json=body)
+            response.raise_for_status()
+
+            if response.status_code == 204:
+                return {"message": "Operation successful, no content returned"}
+            else:
+                return response.json()
+        except requests.exceptions.HTTPError as e:
+            return {"error": str(e), "status_code": response.status_code, "response": response.text}
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+    def logout(self) -> bool:
+        try:
+            accounts = self.app.get_accounts()
+            for account in accounts:
+                self.app.remove_account(account)
+            self.logger.info("Successfully logged out")
+            return True
+        except Exception as e:
+            self.logger.error(f"Error during logout: {str(e)}")
+            return False
+
+
+# Example usage
+if __name__ == "__main__":
+    # These values should come from your Azure AD app registration
+    TENANT_ID = AppConfig().get("MS_TENANT_ID")
+    CLIENT_ID = AppConfig().get("MS_CLIENT_ID")
+    CLIENT_SECRET = AppConfig().get("MS_CLIENT_SECRET")
+    # CLIENT_SECRET = None
+
+    sso = MicrosoftSSO()
+
+    # user_id = sso.get_user_id()
+
+    user_info = sso.get_user_info()
+    if user_info:
+        print(f"Authenticated User ID: {user_info['id']}")
+        print(f"Authenticated User Email: {user_info['email']}")
+    else:
+        print("Failed to authenticate or get user info")
+
+    print(f"\n\nUser list: {sso.get_users()}")
+    result = sso.make_entra_request('{"method": "GET", "path": "users/delta"}')
+    print(f"\n\nEntitlements: {result}")
+    # sso.logout()

quantumdrive-0.1.0/core/aws/__init__.py

@@ -0,0 +1 @@
+