reasoning-deployment-service 0.2.8__tar.gz → 0.2.9__tar.gz

{reasoning_deployment_service-0.2.8 → reasoning_deployment_service-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reasoning-deployment-service
-Version: 0.2.8
+Version: 0.2.9
 Summary: Deployment helper for Vertex AI Reasoning Engines & Agent Spaces
 Author: AxG-AI-Exchange-GenAI-Initiative
 Author-email: Sergio Estrada <sergio.estrada@accenture.com>

{reasoning_deployment_service-0.2.8 → reasoning_deployment_service-0.2.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reasoning-deployment-service"
-version = "0.2.8"
+version = "0.2.9"
 description = "Deployment helper for Vertex AI Reasoning Engines & Agent Spaces"
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -33,4 +33,4 @@ dev = [
 [project.urls]
 
 [tool.setuptools.packages.find]
-where = ["."]
+where = ["reasoning_deployment_service"]

{reasoning_deployment_service-0.2.8 → reasoning_deployment_service-0.2.9/reasoning_deployment_service}/reasoning_deployment_service.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reasoning-deployment-service
-Version: 0.2.8
+Version: 0.2.9
 Summary: Deployment helper for Vertex AI Reasoning Engines & Agent Spaces
 Author: AxG-AI-Exchange-GenAI-Initiative
 Author-email: Sergio Estrada <sergio.estrada@accenture.com>

{reasoning_deployment_service-0.2.8 → reasoning_deployment_service-0.2.9/reasoning_deployment_service}/reasoning_deployment_service.egg-info/SOURCES.txt

@@ -1,14 +1,6 @@
 README.md
 pyproject.toml
 setup.py
-examples/programmatic_usage.py
-reasoning_deployment_service/__init__.py
-reasoning_deployment_service/reasoning_deployment_service.py
-reasoning_deployment_service.egg-info/PKG-INFO
-reasoning_deployment_service.egg-info/SOURCES.txt
-reasoning_deployment_service.egg-info/dependency_links.txt
-reasoning_deployment_service.egg-info/requires.txt
-reasoning_deployment_service.egg-info/top_level.txt
 reasoning_deployment_service/cli_editor/__init__.py
 reasoning_deployment_service/cli_editor/api_client.py
 reasoning_deployment_service/cli_editor/cli_runner.py
@@ -17,8 +9,6 @@ reasoning_deployment_service/cli_editor/google_deps.py
 reasoning_deployment_service/cli_editor/reasoning_engine_creator.py
 reasoning_deployment_service/gui_editor/__init__.py
 reasoning_deployment_service/gui_editor/main.py
-reasoning_deployment_service/gui_editor/requirements_minimal.txt
-reasoning_deployment_service/gui_editor/run_program.sh
 reasoning_deployment_service/gui_editor/src/__init__.py
 reasoning_deployment_service/gui_editor/src/core/__init__.py
 reasoning_deployment_service/gui_editor/src/core/api_client.py
@@ -30,4 +20,9 @@ reasoning_deployment_service/gui_editor/src/ui/agent_space_view.py
 reasoning_deployment_service/gui_editor/src/ui/authorization_view.py
 reasoning_deployment_service/gui_editor/src/ui/reasoning_engine_view.py
 reasoning_deployment_service/gui_editor/src/ui/reasoning_engines_view.py
-reasoning_deployment_service/gui_editor/src/ui/ui_components.py
+reasoning_deployment_service/gui_editor/src/ui/ui_components.py
+reasoning_deployment_service/reasoning_deployment_service.egg-info/PKG-INFO
+reasoning_deployment_service/reasoning_deployment_service.egg-info/SOURCES.txt
+reasoning_deployment_service/reasoning_deployment_service.egg-info/dependency_links.txt
+reasoning_deployment_service/reasoning_deployment_service.egg-info/requires.txt
+reasoning_deployment_service/reasoning_deployment_service.egg-info/top_level.txt

reasoning_deployment_service-0.2.9/reasoning_deployment_service/reasoning_deployment_service.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+cli_editor
+gui_editor

reasoning_deployment_service-0.2.8/examples/programmatic_usage.py

@@ -1,154 +0,0 @@
-#!/usr/bin/env python3
-"""
-Example: Programmatic usage of reasoning deployment service components
-"""
-
-import os
-import threading
-import time
-
-def example_cli_usage():
-    """Example of starting CLI editor programmatically."""
-    print("📋 CLI Editor Example:")
-    print("-" * 30)
-    
-    try:
-        from reasoning_deployment_service.cli_editor import CLIRunner
-        
-        # Create CLI runner
-        cli = CLIRunner()
-        
-        # Note: cli.run() is interactive and will block
-        # For demo purposes, we'll just show it's available
-        print("✅ CLI Runner created successfully")
-        print("💡 To run: cli.run()")
-        print("🔄 This will start an interactive CLI session")
-        
-        return cli
-        
-    except Exception as e:
-        print(f"❌ Error with CLI: {e}")
-        return None
-
-def example_gui_usage():
-    """Example of starting GUI editor programmatically.""" 
-    print("\n🖼️ GUI Editor Example:")
-    print("-" * 30)
-    
-    try:
-        from reasoning_deployment_service.gui_editor import GUIEditor
-        
-        # Note: We don't actually create the GUI to avoid issues in headless environments
-        print("✅ GUI Editor class available")
-        print("💡 To run: app = GUIEditor(); app.mainloop()")
-        print("🔄 This will start the tkinter GUI application")
-        
-        return GUIEditor
-        
-    except Exception as e:
-        print(f"❌ Error with GUI: {e}")
-        return None
-
-def example_core_deployment():
-    """Example of using core deployment service."""
-    print("\n⚙️ Core Deployment Service Example:")
-    print("-" * 40)
-    
-    try:
-        from reasoning_deployment_service import ReasoningEngineDeploymentService
-        
-        print("✅ Core deployment service available")
-        print("💡 Usage:")
-        print("   service = ReasoningEngineDeploymentService(agent, 'DEV')")
-        print("   service.one_deployment_with_everything_on_it()")
-        
-        return ReasoningEngineDeploymentService
-        
-    except Exception as e:
-        print(f"❌ Error with core service: {e}")
-        return None
-
-def example_integrated_workflow():
-    """Example of an integrated workflow."""
-    print("\n🔗 Integrated Workflow Example:")
-    print("-" * 35)
-    
-    print("""
-def integrated_agent_workflow():
-    # 1. Deploy your agent
-    from reasoning_deployment_service import ReasoningEngineDeploymentService
-    from google.adk.agents import BaseAgent
-    
-    class MyAgent(BaseAgent):
-        def invoke(self, input_text: str) -> str:
-            return f"Agent response: {input_text}"
-    
-    agent = MyAgent()
-    service = ReasoningEngineDeploymentService(agent, "DEV")
-    service.one_deployment_with_everything_on_it()
-    
-    # 2. Launch management interface
-    choice = input("Choose interface (cli/gui): ")
-    
-    if choice == "cli":
-        from reasoning_deployment_service.cli_editor import CLIRunner
-        cli = CLIRunner()
-        cli.run()
-    elif choice == "gui":
-        from reasoning_deployment_service.gui_editor import GUIEditor
-        app = GUIEditor()
-        app.mainloop()
-""")
-
-def check_environment():
-    """Check if environment is properly configured."""
-    print("\n🔍 Environment Check:")
-    print("-" * 20)
-    
-    required_vars = [
-        "DEV_PROJECT_ID", "DEV_PROJECT_NUMBER", 
-        "DEV_PROJECT_LOCATION", "DEV_STAGING_BUCKET"
-    ]
-    
-    missing = []
-    for var in required_vars:
-        if not os.getenv(var):
-            missing.append(var)
-    
-    if missing:
-        print(f"⚠️ Missing environment variables: {missing}")
-        print("💡 Set these in your .env file before using the services")
-        return False
-    else:
-        print("✅ Environment variables look good!")
-        return True
-
-def main():
-    """Main example function."""
-    print("🚀 Reasoning Deployment Service - Programmatic Usage Examples")
-    print("=" * 65)
-    
-    # Check environment
-    env_ok = check_environment()
-    
-    # Show component examples
-    cli = example_cli_usage()
-    gui_class = example_gui_usage() 
-    core = example_core_deployment()
-    example_integrated_workflow()
-    
-    # Summary
-    print("\n📝 Summary:")
-    print("-" * 12)
-    print(f"✅ CLI Editor: {'Available' if cli else 'Not available'}")
-    print(f"✅ GUI Editor: {'Available' if gui_class else 'Not available'}")
-    print(f"✅ Core Service: {'Available' if core else 'Not available'}")
-    print(f"✅ Environment: {'Configured' if env_ok else 'Needs setup'}")
-    
-    if cli and gui_class and core:
-        print("\n🎉 All components are ready for programmatic use!")
-    else:
-        print("\n⚠️ Some components may need additional setup or dependencies.")
-
-if __name__ == "__main__":
-    main()

reasoning_deployment_service-0.2.8/reasoning_deployment_service/__init__.py

@@ -1,25 +0,0 @@
-# Initialize the reasoning_deployment_service package
-
-from .reasoning_deployment_service import ReasoningEngineDeploymentService
-
-# Import submodules for optional use
-try:
-    from . import cli_editor
-    from . import gui_editor
-    CLI_AVAILABLE = True
-    GUI_AVAILABLE = True
-except ImportError as e:
-    print(f"Warning: Some optional components not available: {e}")
-    CLI_AVAILABLE = False
-    GUI_AVAILABLE = False
-
-# Make main classes available for direct import
-__all__ = [
-    'ReasoningEngineDeploymentService',
-]
-
-# Add optional components if available
-if CLI_AVAILABLE:
-    __all__.append('cli_editor')
-if GUI_AVAILABLE:
-    __all__.append('gui_editor')

reasoning_deployment_service-0.2.8/reasoning_deployment_service/gui_editor/requirements_minimal.txt

@@ -1,54 +0,0 @@
-# Bare minimum requirements for Agent Space Deployment Service
-# Core functionality dependencies only
-
-# Google Cloud & Vertex AI (CORE REQUIREMENT)
-google-cloud-aiplatform==1.108.0
-vertexai==1.43.0
-google-auth==2.40.3
-google-auth-oauthlib==1.2.2
-google-api-python-client==2.178.0
-
-# Environment management (CORE REQUIREMENT)
-python-dotenv==1.1.1
-
-# HTTP requests (CORE REQUIREMENT)
-requests==2.32.4
-
-# Google Cloud dependencies (CORE REQUIREMENT)
-google-api-core==2.25.1
-googleapis-common-protos==1.70.0
-grpcio==1.74.0
-protobuf==6.31.1
-
-# Authentication dependencies (CORE REQUIREMENT)  
-google-auth-httplib2==0.2.0
-cachetools==5.5.2
-pyasn1==0.6.1
-pyasn1_modules==0.4.2
-rsa==4.9.1
-
-# Core Python utilities (CORE REQUIREMENT)
-certifi==2025.8.3
-urllib3==2.5.0
-six==1.17.0
-
-# OPTIONAL: For enhanced functionality
-# Uncomment if you need these features:
-
-# For MCP server support:
-# mcp==1.12.4
-
-# For FastAPI endpoints (if you plan to add web interface):
-# fastapi==0.116.1
-# uvicorn==0.35.0
-# pydantic==2.11.7
-
-# For document processing in agents:
-# PyPDF2==3.0.1
-# python-docx==1.2.0
-
-# For web scraping/HTTP in agents:
-# httpx==0.28.1
-
-# For YAML configuration:
-# PyYAML==6.0.2

reasoning_deployment_service-0.2.8/reasoning_deployment_service/gui_editor/run_program.sh

@@ -1,55 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-VENV_DIR=".venv"
-
-# Detect Python executable
-if command -v python3 &>/dev/null; then
-    PYTHON=python3
-elif command -v python &>/dev/null; then
-    PYTHON=python
-else
-    echo "❌ Python is not installed. Please install Python 3.9+."
-    exit 1
-fi
-
-# Create venv if missing
-if [ ! -d "$VENV_DIR" ]; then
-    echo "🔧 Creating virtual environment..."
-    $PYTHON -m venv "$VENV_DIR"
-fi
-
-# Activate venv (POSIX)
-if [ -f "$VENV_DIR/bin/activate" ]; then
-    source "$VENV_DIR/bin/activate"
-# Activate venv (Windows Git Bash or Cygwin)
-elif [ -f "$VENV_DIR/Scripts/activate" ]; then
-    source "$VENV_DIR/Scripts/activate"
-else
-    echo "❌ Could not find venv activation script."
-    exit 1
-fi
-
-# Install Tkinter if on Linux
-if [[ "$OSTYPE" == "linux-gnu"* ]]; then
-    echo "🖼  Installing Tkinter for Linux..."
-    if command -v apt-get &>/dev/null; then
-        sudo apt-get update && sudo apt-get install -y python3-tk
-    elif command -v dnf &>/dev/null; then
-        sudo dnf install -y python3-tkinter
-    elif command -v pacman &>/dev/null; then
-        sudo pacman -S --noconfirm tk
-    else
-        echo "⚠️ Could not determine package manager. Install python3-tk manually."
-    fi
-fi
-
-# Install dependencies
-echo "📦 Installing dependencies..."
-pip3 install --upgrade pip
-# Install the reasoning deployment service with GUI extras
-pip3 install "reasoning-deployment-service[gui]"
-
-# Run your app
-echo "🚀 Starting app..."
-$PYTHON main.py

reasoning_deployment_service-0.2.8/reasoning_deployment_service/reasoning_deployment_service.py

@@ -1,687 +0,0 @@
-import json, os, subprocess, yaml, sys
-import urllib.parse, vertexai, google.auth
-import requests as _requests
-from typing import Tuple
-from pathlib import Path
-from dotenv import load_dotenv
-from vertexai import agent_engines
-from google.adk.agents import BaseAgent
-from google.auth.transport.requests import Request as GoogleAuthRequest
-from google.api_core.exceptions import NotFound
-import logging
-from datetime import datetime
-
-DISCOVERY_ENGINE_URL = "https://discoveryengine.googleapis.com/v1alpha"
-
-class ReasoningEngineDeploymentService:
-    def __init__(self, root_agent: BaseAgent, deployment_environment: str="DEV"):
-        # Setup logging
-        self._setup_logging()
-        
-        self._check_required_files_exist()
-        load_dotenv(dotenv_path=".env.agent", override=True)
-
-        self.root_agent = root_agent
-        self.deployment_env = deployment_environment
-        self.attempt_to_use_existing_auth = False
-        
-        self._staging_bucket = None
-        self._project_id = None
-        self._project_number = None
-        self._project_location = None
-        self._oauth_client_id = None
-        self._oauth_client_secret = None
-        self._agent_space_engine = None
-
-
-        self._load_agent_definition()
-        self._load_deployment_environment_variables(deployment_environment=deployment_environment)
-        self._check_requirements_file_present()
-         
-        self._http = _requests.Session()
-        self._http.headers.update({"Content-Type": "application/json"})
-        self.authenticate()
-
-    def _setup_logging(self):
-        os.makedirs("logs", exist_ok=True)
-        
-        # Setup logger
-        self.logger = logging.getLogger("ReasoningEngineDeployment")
-        self.logger.setLevel(logging.DEBUG)
-        self.logger.propagate = False  
-
-        if not self.logger.handlers:
-            self.log_filename = f"logs/deployment_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
-            file_handler = logging.FileHandler(self.log_filename)
-            file_handler.setLevel(logging.DEBUG)
-            
-            console_handler = logging.StreamHandler()
-            console_handler.setLevel(logging.INFO)
-            
-            file_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-            file_handler.setFormatter(file_formatter)
-            
-            console_formatter = logging.Formatter('%(message)s')
-            console_handler.setFormatter(console_formatter)
-            
-            self.logger.addHandler(file_handler)
-            self.logger.addHandler(console_handler)
-        
-        logging.getLogger('google').setLevel(logging.ERROR)
-        logging.getLogger('urllib3').setLevel(logging.ERROR)
-        logging.getLogger('requests').setLevel(logging.ERROR)
-
-    def _log_record_file(self, level="ERROR"):
-        """Log the current deployment record file contents to file only."""
-        try:
-            record = self._read_engine_deployment_record()
-            if record:
-                record_str = json.dumps(record, indent=2)
-                # Write directly to the same log file without terminal output
-                with open(self.log_filename, 'a') as f:
-                    timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S,%f')[:-3]
-                    f.write(f"{timestamp} - ReasoningEngineDeployment - {level} - Current deployment record:\n{record_str}\n")
-        except Exception as e:
-            self.logger.error(f"Failed to read deployment record: {e}")
-
-    def error(self, message: str):
-        self.logger.error(f"[DEPLOYMENT SERVICE: CRITICAL FAILURE]: {message}")
-        self._log_record_file("ERROR")
-
-    def warning(self, message: str):
-        self.logger.warning(f"[DEPLOYMENT SERVICE: WARNING]: {message}")
-
-    def info(self, message: str):
-        self.logger.info(f"[DEPLOYMENT SERVICE: INFO]: {message}")
-
-    def _check_required_files_exist(self):
-        end_run = False
-        if not os.path.exists(".env.agent"):
-            self.warning("Creating .env.agent file ... done")
-            self._generate_env_agent()
-            end_run = True
-        
-        if not os.path.exists("aix_agent.yaml"):
-            self._generate_example_yaml_config()
-            self.warning("Creating aix_agent.yaml file ... done")
-            end_run = True
-
-        self.warning("Please fill in the required values in the generated files and re-run the deployment.")
-
-        if end_run:
-            sys.exit(1)
-
-    def _access_token(self) -> str:
-        """Live: fetch ADC access token; raises if not available."""
-        creds, _ = google.auth.default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
-
-        if not creds.valid or (creds.expired and creds.refresh_token):
-            creds.refresh(GoogleAuthRequest())
-        return creds.token
-
-    def authenticate(self) -> bool:
-        try:
-            _ = self._access_token()
-            return True
-        except Exception:
-            pass
-
-        try:
-            subprocess.run(["gcloud", "--version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
-        except Exception:
-            raise RuntimeError("'gcloud' not found on PATH. Install Google Cloud SDK.")
-
-        proc = subprocess.run(
-            ["gcloud", "auth", "application-default", "login"],
-            stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True
-        )
-        if proc.returncode != 0:
-            raise RuntimeError(f"ADC auth failed:\n{proc.stdout}")
-
-        _ = self._access_token()
-        return True
-
-    def _get_deployment_record_path(self):
-        return Path("deployments") / f"{self.deployment_env}_{self._reasoning_engine_name}.json"
-
-    def _read_engine_deployment_record(self) -> dict:
-        file_path = self._get_deployment_record_path()
-        if os.path.exists(file_path):
-            with open(file_path, "r") as f:
-                return json.load(f) or {}
-        return {}
-
-    def _write_engine_deployment(self, json_payload: dict):
-        if not os.path.exists("deployments"):
-            self.info(f"Creating deployments directory")
-            os.makedirs("deployments")
-
-        file_path = self._get_deployment_record_path()
-        read_engine_deployment = self._read_engine_deployment_record()
-
-        if read_engine_deployment:
-            read_engine_deployment.update(json_payload)
-
-            with open(file_path, "w") as f:
-                json.dump(read_engine_deployment, f, sort_keys=False)
-
-                self.info(f"Successfully wrote entry {json_payload} to {file_path}")
-            return
-        
-        with open(file_path, "w") as f:
-            self.info(f"Successfully created {file_path}")
-            json.dump(json_payload, f, sort_keys=False)
-            self.info(f"Successfully wrote entry {json_payload} to {file_path}")
-
-    def _generate_env_agent(self, path: str | Path = ".env.agent", overwrite: bool = False) -> Path:
-        """
-        Generate a .env.agent template file with all deployment profile
-        and app environment variables, left empty for later filling.
-        """
-        path = Path(path)
-        if path.exists() and not overwrite:
-            raise FileExistsError(f"{path} already exists. Pass overwrite=True to replace it.")
-
-        template = """#===================== **** DEPLOYMENT PROFILE **** =====================
-    # Development Profile
-    DEV_PROJECT_ID=
-    DEV_PROJECT_NUMBER=
-    DEV_PROJECT_LOCATION=
-    DEV_STAGING_BUCKET=
-    DEV_AGENT_SPACE_ENGINE=
-    DEV_API_TOKEN=
-    DEV_OAUTH_CLIENT_ID=
-    DEV_OAUTH_CLIENT_SECRET=
-
-    # Production Profile
-    PROD_PROJECT_ID=
-    PROD_PROJECT_NUMBER=
-    PROD_PROJECT_LOCATION=
-    PROD_STAGING_BUCKET=
-    PROD_AGENT_SPACE_ENGINE=
-    PROD_API_TOKEN=
-    PROD_OAUTH_CLIENT_ID=
-    PROD_OAUTH_CLIENT_SECRET=
-
-    REASONING_DEPLOYMENT_VERSION=0.2.4
-    #===================== **** DEPLOYMENT PROFILE **** =====================
-
-
-    #===================== **** YOUR APP ENV VARIABLES **** =====================
-    DEVELOPER=
-    #===================== **** YOUR APP ENV VARIABLES **** =====================
-    """
-
-        path.write_text(template.strip() + "\n")
-        
-        # Also update .gitignore to include logs
-        self._update_gitignore()
-        
-        return path
-
-    def _update_gitignore(self):
-        """Add common ignore patterns to .gitignore."""
-        gitignore_path = Path(".gitignore")
-        patterns_to_add = [
-            "logs/",
-            "deployments/", 
-            ".env.agent",
-            "__pycache__/",
-            "*.pyc",
-            ".venv/",
-            "deploy_env/"
-        ]
-        
-        existing_patterns = set()
-        if gitignore_path.exists():
-            existing_patterns = set(gitignore_path.read_text().splitlines())
-        
-        new_patterns = [p for p in patterns_to_add if p not in existing_patterns]
-        
-        if new_patterns:
-            with open(gitignore_path, "a") as f:
-                if existing_patterns:  # Add newline if file has content
-                    f.write("\n")
-                f.write("# Added by ReasoningEngineDeploymentService\n")
-                for pattern in new_patterns:
-                    f.write(f"{pattern}\n")
-
-    def _generate_example_yaml_config(self, path: str | Path = "aix_agent.yaml", overwrite: bool = False) -> Path:
-        """
-        Create an example YAML config matching the requested schema.
-
-        Structure:
-        defaults:
-        scopes: [ ... ]
-        metadata: { ... }
-        auth: { ... }
-        environment_variables: [ ... ]
-        """
-        path = Path(path)
-        if path.exists() and not overwrite:
-            raise FileExistsError(f"{path} already exists. Pass overwrite=True to replace it.")
-
-        config = {
-            "defaults": {
-                "scopes": [
-                    "https://www.googleapis.com/auth/cloud-platform",
-                    "https://www.googleapis.com/auth/userinfo.email",
-                ],
-                "metadata": {
-                    "reasoning_engine_name": "reasoning-engine-dev",
-                    "reasoning_engine_description": "A reasoning engine for development",
-                    "agent_space_name": "Agent Space Dev Numba Three!",
-                    "agent_space_description": "Agent spece description, lets go",
-                    "agent_space_tool_description": "Agent space tool description",
-                },
-                "agent_folder": "your_agent_folder",
-                "auth": {
-                    "oauth_authorization_id": "test_auth_three",
-                },
-                "environment_variables": [
-                    "DEVELOPER",
-                ],
-            }
-        }
-
-        path.write_text(yaml.safe_dump(config, sort_keys=False))
-        return path
- 
-    def _load_agent_definition(self):
-        try:
-            with open("aix_agent.yaml", "r") as f:
-                config = yaml.safe_load(f)
-        except FileNotFoundError:
-            self._generate_example_yaml_config()
-            self.error("Could not locate a valid aix_agent.yaml file. Generating example file in your directory.")
-            sys.exit(1)
-
-        try:
-            config = config['defaults']
-            scopes = config['scopes']
-            metadata = config['metadata']
-            agent_folder = config['agent_folder']
-            auth = config['auth']
-            environment_variables = config['environment_variables']
-
-            reasoning_engine_name = metadata['reasoning_engine_name']
-            reasoning_engine_description = metadata['reasoning_engine_description']
-            agent_space_name = metadata['agent_space_name']
-            agent_space_description = metadata['agent_space_description']
-            agent_space_tool_description = metadata["agent_space_tool_description"]
-
-            self._required_scopes = scopes
-            self._agent_folder = agent_folder
-            self._reasoning_engine_name = reasoning_engine_name
-            self._reasoning_engine_description = reasoning_engine_description
-            self._agent_space_name = agent_space_name
-            self._agent_space_description = agent_space_description
-            self._agent_space_tool_description = agent_space_tool_description
-            self._authorization_id = auth.get("oauth_authorization_id", None)
-            self._environment_variables = environment_variables or []
-        except KeyError as e:
-             raise RuntimeError(f"Missing required key in aix_agent.yaml: {e}")
-        
-    def _load_deployment_environment_variables(self, deployment_environment: str):
-        required_vars = ['PROJECT_ID', 'PROJECT_NUMBER', 'PROJECT_LOCATION', 'STAGING_BUCKET', 'AGENT_SPACE_ENGINE']
-        
-        for var in required_vars:
-            env_var = f"{deployment_environment}_{var}"
-            if env_var not in os.environ or not os.getenv(env_var):
-                raise RuntimeError(f"Missing required environment variable: {env_var}.")
-            
-            setattr(self, f"_{var.lower()}", os.getenv(env_var))
-
-        if self._authorization_id:
-            required_auth_vars = ['OAUTH_CLIENT_ID', 'OAUTH_CLIENT_SECRET']
-
-            for var in required_auth_vars:
-                env_var = f"{deployment_environment}_{var}"
-                if env_var not in os.environ or not os.getenv(env_var):
-                    raise RuntimeError(f"Missing required environment variable: {env_var}")
-
-                setattr(self, f"_{var.lower()}", os.getenv(env_var))
-
-    def _check_requirements_file_present(self):
-        if not os.path.exists("requirements.txt"):
-            raise RuntimeError("Missing requirements.txt file")
-        
-    def _load_requirements(self):
-        with open("requirements.txt", "r") as f:
-            return [line.strip() for line in f if line.strip()]
-
-    def create_reasoning_engine(self):
-        vertexai.init(
-            project=self._project_id,
-            location=self._project_location,
-            staging_bucket=self._staging_bucket,
-        )
-
-        creation = agent_engines.create(
-            self.root_agent,
-            display_name=self._reasoning_engine_name,
-            description=self._reasoning_engine_description,
-            requirements=self._load_requirements(),
-            env_vars=self._environment_variables,
-            extra_packages=[f"./{self._agent_folder}"]
-        )
-
-        if creation:
-            self.info(f"Reasoning engine created successfully: {creation.resource_name}")
-
-        json_payload = {"reasoning_engine_id": creation.resource_name}
-        self._write_engine_deployment(json_payload)
-
-    def update_reasoning_engine(self, reasoning_engine_id):
-        vertexai.init(
-            project=self._project_id,
-            location=self._project_location,
-            staging_bucket=self._staging_bucket,
-        )
-
-        try:
-            updating = agent_engines.update(
-                resource_name=reasoning_engine_id,
-                agent_engine=self.root_agent,
-                display_name=self._reasoning_engine_name,
-                description=self._reasoning_engine_description,
-                requirements=self._load_requirements(),
-                env_vars=self._environment_variables,
-                extra_packages=[f"./{self._agent_folder}"]
-            )
-        except NotFound as e:
-            self.error(f"Reasoning engine {reasoning_engine_id} not found. Cannot update.")
-            self.error(f"Please inspect using CLI, GUI or GCP Interface to identify root cause.")
-            self.error(f"Deleting deployment record {self._get_deployment_record_path()} to allow re-creation.")
-            self.error(f"System reported: {e}")
-            os.remove(self._get_deployment_record_path())
-            sys.exit(1)
-            
-
-        if updating:
-            self.info(f"Reasoning engine updated successfully: {updating.resource_name}")
-
-        self._write_engine_deployment({'reasoning_engine_id': updating.resource_name})
-
-    def _get_agent_space_payload(self, reasoning_engine: str) -> Tuple[dict, dict]:
-        headers = {
-            "Authorization": f"Bearer {self._access_token()}",
-            "Content-Type": "application/json",
-            "X-Goog-User-Project": self._project_number,
-        }
-        payload = {
-            "displayName": self._agent_space_name,
-            "description": self._agent_space_description,
-            "adk_agent_definition": {
-                "tool_settings": {"tool_description": self._agent_space_tool_description},
-                "provisioned_reasoning_engine": {"reasoning_engine": reasoning_engine},
-            },
-        }
-
-        if self._authorization_id:
-            payload["adk_agent_definition"]["authorizations"] = [
-                f"projects/{self._project_number}/locations/global/authorizations/{self._authorization_id}"
-            ]
-
-        return headers, payload
-    
-    def _get_agent_space_agent_url_new(self):
-        return (f"{DISCOVERY_ENGINE_URL}/projects/{self._project_number}/locations/global/collections/default_collection/"
-               f"engines/{self._agent_space_engine}/assistants/default_assistant/agents")
-
-    def _deploy_to_agent_space(self):
-        get_reasoning_engine = self._read_engine_deployment_record()
-
-        if not get_reasoning_engine or not get_reasoning_engine.get("reasoning_engine_id"):
-            return ("failed", "Reasoning engine required before deploy", None)
-        
-        if get_reasoning_engine.get("agent_space_id"):
-            self.warning("Agent space already exists; skipping creation.")
-            
-            return
-
-        headers, payload = self._get_agent_space_payload(get_reasoning_engine["reasoning_engine_id"])
-        url = self._get_agent_space_agent_url_new()
-        r = self._http.post(url, headers=headers, json=payload, timeout=90)
-
-        if r.status_code < 400:
-            self.info("Agent space deployed successfully.")
-            if self.attempt_to_use_existing_auth:
-                self.warning("Using existing authorization.")
-                self._write_engine_deployment({"authorization_id": self._authorization_id, 'scopes': self._required_scopes})
-            self._write_engine_deployment({"agent_space_id": r.json().get("name")})
-        else:
-            # Log API failure details to file only
-            with open(self.log_filename, 'a') as f:
-                timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S,%f')[:-3]
-                f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Agent space deployment failed with status {r.status_code} {r.reason}\n")
-                f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - URL: {r.url}\n")
-                f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Response: {r.text}\n")
-                if r.headers.get('content-type', '').startswith('application/json'):
-                    try:
-                        error_json = r.json()
-                        f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Error details: {json.dumps(error_json, indent=2)}\n")
-                    except:
-                        pass
-            
-            # Terminal message - simple
-            self.error("Agent space deployment failed")
-            # This will also log the record file
-
-    def _update_in_agent_space(self):
-        get_reasoning_engine = self._read_engine_deployment_record()
-
-        if not get_reasoning_engine or not get_reasoning_engine.get("reasoning_engine_id"):
-            return ("failed", "Reasoning engine required before update", None)
-        
-        if not get_reasoning_engine.get("agent_space_id"):
-            self.warning("No agent space to update; skipping.")
-            return
-
-        headers, payload = self._get_agent_space_payload(get_reasoning_engine["reasoning_engine_id"])
-        url = f'{DISCOVERY_ENGINE_URL}/' + get_reasoning_engine.get("agent_space_id")
-        r = self._http.patch(url, headers=headers, json=payload, timeout=90)
-
-        if r.status_code < 400:
-            if self.attempt_to_use_existing_auth:
-                self.info("Using existing authorization.")
-                self._write_engine_deployment({"authorization_id": self._authorization_id, 'scopes': self._required_scopes})
-            self.info("Agent space updated successfully.")
-            return True
-        else:
-            # Log API failure details to file only
-            with open(self.log_filename, 'a') as f:
-                timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S,%f')[:-3]
-                f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Failed to update agent space with status {r.status_code} {r.reason}\n")
-                f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - URL: {r.url}\n")
-                f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Response: {r.text}\n")
-                if r.headers.get('content-type', '').startswith('application/json'):
-                    try:
-                        error_json = r.json()
-                        f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Error details: {json.dumps(error_json, indent=2)}\n")
-                    except:
-                        pass
-            
-            # Terminal message - simple
-            self.error("Failed to update agent space")
-            # This will also log the record file
-            return False
-
-    def _build_authorization_uri(self, client_id: str, scopes: list[str]) -> str:
-        base = "https://accounts.google.com/o/oauth2/auth"
-        query = {
-            "response_type": "code",
-            "client_id": client_id,
-            "scope": " ".join(scopes),
-            "access_type": "offline",
-            "prompt": "consent",
-        }
-        return f"{base}?{urllib.parse.urlencode(query)}"
-
-    def _create_authorization(self) -> dict:
-        read_authorizations = self._read_engine_deployment_record()
-
-        if not self._authorization_id:
-            self.warning("No authorization ID provided; skipping authorization creation.")
-
-            return
-
-        if read_authorizations and (read_authorizations.get("authorization_id") and read_authorizations.get("authorization_id") == self._authorization_id):
-            self.warning("Authorization already exists; skipping creation.")
-
-            return
-        
-        discovery_engine_url = "https://discoveryengine.googleapis.com/v1alpha"
-        headers = {
-            "Authorization": f"Bearer {self._access_token()}",
-            "Content-Type": "application/json",
-            "X-Goog-User-Project": self._project_number,
-        }
-
-        client_id = self._oauth_client_id or "your-client-id"
-        client_secret = self._oauth_client_secret or "your-client-secret"
-
-        payload = {
-            "name": f"projects/{self._project_number}/locations/global/authorizations/{self._authorization_id}",
-            "serverSideOauth2": {
-                "clientId": client_id,
-                "clientSecret": client_secret,
-                "authorizationUri": self._build_authorization_uri(client_id, self._required_scopes),
-                "tokenUri": "https://oauth2.googleapis.com/token",
-            },
-        }
-
-        url = (
-            f"{discovery_engine_url}/projects/{self._project_id}/locations/global/authorizations"
-            f"?authorizationId={self._authorization_id}"
-        )
-
-        r = self._http.post(url, headers=headers, json=payload, timeout=60)
-
-        if r.status_code < 400:
-            payload = {"authorization_id": self._authorization_id, 'scopes': self._required_scopes}
-            self._write_engine_deployment(payload)
-            return True
-        
-        if r.status_code == 409:
-            self.warning("Authorization conflict detected; attempting to use existing authorization.")
-            self.logger.debug(f"Conflict response: {r.text}")
-            self.attempt_to_use_existing_auth = True
-        elif r.status_code >= 400:
-            # Log API failure details to file only
-            with open(self.log_filename, 'a') as f:
-                timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S,%f')[:-3]
-                f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Authorization creation failed with status {r.status_code} {r.reason}\n")
-                f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - URL: {r.url}\n")
-                f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Response: {r.text}\n")
-                if r.headers.get('content-type', '').startswith('application/json'):
-                    try:
-                        error_json = r.json()
-                        f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Error details: {json.dumps(error_json, indent=2)}\n")
-                    except:
-                        pass
-            
-            # Terminal message - simple
-            self.error("Authorization creation failed")
-            # This will also log the record file
-
-
-    def _drop_authorization(self) -> bool:
-        temp_auth = self._authorization_id
-        self._authorization_id = None
-        self._update_in_agent_space()
-        self._authorization_id = temp_auth
-
-        read_record = self._read_engine_deployment_record()
-        read_record.pop("authorization_id", None)
-
-        file_path = self._get_deployment_record_path()
-
-        with open(file_path, "w") as f:
-            json.dump(read_record, f, sort_keys=False, indent=2)
-
-        self.info("Authorization dropped successfully")
-
-        return True
-    
-    def _delete_authorization(self):
-        if not self._authorization_id:
-            self.warning("No authorization ID provided; skipping deletion.")
-            return
-
-        discovery_engine_url = "https://discoveryengine.googleapis.com/v1alpha"
-        headers = {
-            "Authorization": f"Bearer {self._access_token()}",
-            "Content-Type": "application/json",
-            "X-Goog-User-Project": self._project_number,
-        }
-
-        url = (
-            f"{discovery_engine_url}/projects/{self._project_id}/locations/global/authorizations"
-            f"?authorizationId={self._authorization_id}"
-        )
-
-        r = self._http.delete(url, headers=headers, timeout=60)
-
-        if r.status_code < 400:
-            self.info("Authorization deleted successfully.")
-            self._authorization_id = None
-            self._update_in_agent_space()
-            return True
-
-        # Log API failure details to file only
-        with open(self.log_filename, 'a') as f:
-            timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S,%f')[:-3]
-            f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Failed to delete authorization with status {r.status_code} {r.reason}\n")
-            f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - URL: {r.url}\n")
-            f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Response: {r.text}\n")
-            if r.headers.get('content-type', '').startswith('application/json'):
-                try:
-                    error_json = r.json()
-                    f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Error details: {json.dumps(error_json, indent=2)}\n")
-                except:
-                    pass
-        
-        # Terminal message - simple
-        self.error("Failed to delete authorization")
-        # This will also log the record file
-        return False
-
-    def one_deployment_with_everything_on_it(self, skip_engine_step=False):
-        read_engine = self._read_engine_deployment_record()
-
-    
-        if not skip_engine_step:
-            if read_engine and read_engine.get("reasoning_engine_id"):
-                self.info("Updating reasoning engine ... ")
-                self.update_reasoning_engine(read_engine["reasoning_engine_id"])
-                self.info("Done!")
-            else:
-                self.create_reasoning_engine()
-        else:
-            if not read_engine or not read_engine.get("reasoning_engine_id"):
-                self.warning("Skipping reasoning engine step, but no existing engine found in record.")
-                self.warning("Please ensure the reasoning engine exists before proceeding. Ending Agent Space update attempt")
-
-                sys.exit(1)
-
-        needs_auth_reset = False
-
-        if not read_engine or read_engine.get("authorization_id") != self._authorization_id:
-            self.warning("Detected change in authorization ID")
-            needs_auth_reset = True
-
-        elif read_engine and read_engine.get("scopes") != self._required_scopes:
-            self.warning("Detected change in authorization scopes")
-            needs_auth_reset = True
-
-        if needs_auth_reset:
-            self.info("Resetting authorization...")
-            self._drop_authorization()
-            self._create_authorization()
-
-        if not read_engine or (read_engine and not read_engine.get("agent_space_id")):
-            self.info("Creating agent space ... ")
-            self._deploy_to_agent_space()
-        else:
-            self._update_in_agent_space()

reasoning_deployment_service-0.2.8/reasoning_deployment_service.egg-info/top_level.txt

@@ -1,3 +0,0 @@
-dist
-examples
-reasoning_deployment_service