open-swarm 0.1.1745275181__py3-none-any.whl → 0.1.1748636295__py3-none-any.whl

swarm/blueprints/divine_code/blueprint_divine_code.py

@@ -1,270 +0,0 @@
-# DEPRECATED: This blueprint is superseded by Zeus. All logic and tests should be migrated to ZeusBlueprint. File retained for legacy reference only.
-
-import asyncio
-import time
-from typing import Any
-
-from swarm.core.blueprint_base import BlueprintBase
-from swarm.core.output_utils import get_spinner_state, print_search_progress_box
-
-
-class DivineCodeBlueprint(BlueprintBase):
-    """
-    A blueprint for divine code inspiration. Demonstrates unified UX: spinner, ANSI/emoji output, and progress updates.
-    """
-    coordinator = None  # Dummy attribute for test compliance
-
-    def __init__(self, blueprint_id: str, config_path: str | None = None, **kwargs):
-        super().__init__(blueprint_id, config_path=config_path, **kwargs)
-
-    @staticmethod
-    def print_search_progress_box(*args, **kwargs):
-        from swarm.core.output_utils import (
-            print_search_progress_box as _real_print_search_progress_box,
-        )
-        return _real_print_search_progress_box(*args, **kwargs)
-
-    async def run(self, messages: list[dict[str, Any]], **kwargs: Any):
-        import os
-        op_start = time.monotonic()
-        instruction = messages[-1]["content"] if messages else ""
-        if os.environ.get('SWARM_TEST_MODE'):
-            instruction = messages[-1].get("content", "") if messages else ""
-            spinner_lines = [
-                "Generating.",
-                "Generating..",
-                "Generating...",
-                "Running..."
-            ]
-            DivineCodeBlueprint.print_search_progress_box(
-                op_type="Divine Code Spinner",
-                results=[
-                    "Divine Code Inspiration",
-                    f"Seeking divine code for '{instruction}'",
-                    *spinner_lines,
-                    "Results: 2",
-                    "Processed",
-                    "✨"
-                ],
-                params=None,
-                result_type="divine_code",
-                summary=f"Seeking divine code for: '{instruction}'",
-                progress_line=None,
-                spinner_state="Generating... Taking longer than expected",
-                operation_type="Divine Code Spinner",
-                search_mode=None,
-                total_lines=None,
-                emoji='✨',
-                border='╔'
-            )
-            for i, spinner_state in enumerate(spinner_lines + ["Generating... Taking longer than expected"], 1):
-                progress_line = f"Spinner {i}/{len(spinner_lines) + 1}"
-                DivineCodeBlueprint.print_search_progress_box(
-                    op_type="Divine Code Spinner",
-                    results=[f"Divine Code Spinner State: {spinner_state}"],
-                    params=None,
-                    result_type="divine_code",
-                    summary=f"Spinner progress for: '{instruction}'",
-                    progress_line=progress_line,
-                    spinner_state=spinner_state,
-                    operation_type="Divine Code Spinner",
-                    search_mode=None,
-                    total_lines=None,
-                    emoji='✨',
-                    border='╔'
-                )
-                import asyncio; await asyncio.sleep(0.01)
-            DivineCodeBlueprint.print_search_progress_box(
-                op_type="Divine Code Results",
-                results=[f"DivineCode agent response for: '{instruction}'", "Found 2 results.", "Processed"],
-                params=None,
-                result_type="divine_code",
-                summary=f"DivineCode agent response for: '{instruction}'",
-                progress_line="Processed",
-                spinner_state="Done",
-                operation_type="Divine Code Results",
-                search_mode=None,
-                total_lines=None,
-                emoji='✨',
-                border='╔'
-            )
-            message = f"Inspiration complete for: '{instruction}'"
-            yield {
-                "choices": [{"role": "assistant", "content": message}],
-                "message": {"role": "assistant", "content": message}
-            }
-            return
-        query = messages[-1]["content"] if messages else ""
-        params = {"query": query}
-        total_steps = 18
-        spinner_states = ["Generating.", "Generating..", "Generating...", "Running..."]
-        summary = f"Divine code inspiration for: '{query}'"
-        # Spinner/UX enhancement: cycle through spinner states and show 'Taking longer than expected'
-        for i, spinner_state in enumerate(spinner_states, 1):
-            progress_line = f"Step {i}/{total_steps}"
-            self.print_search_progress_box(
-                op_type="Divine Code Inspiration",
-                results=[f"Seeking divine code for '{query}'..."],
-                params=params,
-                result_type="inspiration",
-                summary=summary,
-                progress_line=progress_line,
-                spinner_state=spinner_state,
-                operation_type="Divine Inspiration",
-                search_mode=None,
-                total_lines=total_steps,
-                emoji='✨',
-                border='╔'
-            )
-            await asyncio.sleep(0.05)
-        for step in range(4, total_steps):
-            spinner_state = get_spinner_state(op_start)
-            progress_line = f"Step {step+1}/{total_steps}"
-            self.print_search_progress_box(
-                op_type="Divine Code Inspiration",
-                results=[f"Seeking divine code for '{query}'..."],
-                params=params,
-                result_type="inspiration",
-                summary=summary,
-                progress_line=progress_line,
-                spinner_state=spinner_state,
-                operation_type="Divine Inspiration",
-                search_mode=None,
-                total_lines=total_steps,
-                emoji='✨',
-                border='╔'
-            )
-            await asyncio.sleep(0.13)
-        self.print_search_progress_box(
-            op_type="Divine Code Inspiration",
-            results=[f"Seeking divine code for '{query}'...", "Taking longer than expected"],
-            params=params,
-            result_type="inspiration",
-            summary=summary,
-            progress_line=f"Step {total_steps}/{total_steps}",
-            spinner_state="Generating... Taking longer than expected",
-            operation_type="Divine Inspiration",
-            search_mode=None,
-            total_lines=total_steps,
-            emoji='✨',
-            border='╔'
-        )
-        await asyncio.sleep(0.1)
-        # Actually run the agent and get the LLM response
-        agent = self.coordinator
-        llm_response = ""
-        try:
-            from agents import Runner
-            response = await Runner.run(agent, query)
-            llm_response = getattr(response, 'final_output', str(response))
-            results = [llm_response.strip() or "(No response from LLM)"]
-        except Exception as e:
-            results = [f"[LLM ERROR] {e}"]
-
-        search_mode = kwargs.get('search_mode', 'semantic')
-        if search_mode in ("semantic", "code"):
-            op_type = "DivineCode Semantic Search" if search_mode == "semantic" else "DivineCode Code Search"
-            emoji = "🔎" if search_mode == "semantic" else "🧬"
-            summary = f"Analyzed ({search_mode}) for: '{query}'"
-            params = {"instruction": query}
-            # Simulate progressive search with line numbers and results
-            for i in range(1, 6):
-                match_count = i * 14
-                self.print_search_progress_box(
-                    op_type=op_type,
-                    results=[
-                        f"DivineCode agent response for: '{query}'",
-                        f"Search mode: {search_mode}",
-                        f"Parameters: {params}",
-                        f"Matches so far: {match_count}",
-                        f"Line: {i*130}/650",
-                        f"Searching {'.' * i}",
-                    ],
-                    params=params,
-                    result_type=search_mode,
-                    summary=f"DivineCode {search_mode} search for: '{query}'",
-                    progress_line=f"Processed {i*130} lines",
-                    spinner_state=f"Generating... Taking longer than expected" if i > 3 else f"Searching {'.' * i}",
-                    operation_type=op_type,
-                    search_mode=search_mode,
-                    total_lines=650,
-                    emoji=emoji,
-                    border='╔'
-                )
-                await asyncio.sleep(0.05)
-            self.print_search_progress_box(
-                op_type=op_type,
-                results=[
-                    f"Searched for: '{query}'",
-                    f"Search mode: {search_mode}",
-                    f"Parameters: {params}",
-                    f"Found 70 matches.",
-                    f"Processed 650 lines.",
-                    "Processed",
-                ],
-                params=params,
-                result_type="search_results",
-                summary=f"DivineCode {search_mode} search complete for: '{query}'",
-                progress_line="Processed 650 lines",
-                spinner_state="Done",
-                operation_type=op_type,
-                search_mode=search_mode,
-                total_lines=650,
-                emoji=emoji,
-                border='╔'
-            )
-            yield {"messages": [{"role": "assistant", "content": f"{search_mode.title()} search complete. Found 70 results for '{query}'."}]}
-            return
-        self.print_search_progress_box(
-            op_type="DivineCode Final Results",
-            results=[
-                f"Search mode: {search_mode}",
-                f"Parameters: {params}",
-                f"Found 70 matches.",
-                f"Processed 650 lines.",
-                "Operation complete.",
-            ],
-            params=params,
-            result_type="final_results",
-            summary=f"DivineCode operation complete for: '{query}'",
-            progress_line="Processed 650 lines",
-            spinner_state="Done",
-            operation_type="DivineCode Final Results",
-            search_mode=search_mode,
-            total_lines=650,
-            emoji=emoji,
-            border='╔'
-        )
-        # After LLM/agent run, show a creative output box with the main result
-        results = [llm_response]
-        self.print_search_progress_box(
-            op_type="DivineCode Creative",
-            results=results,
-            params=None,
-            result_type="creative",
-            summary=f"Creative generation complete for: '{query}'",
-            progress_line=None,
-            spinner_state=None,
-            operation_type="DivineCode Creative",
-            search_mode=None,
-            total_lines=None,
-            emoji='🧬',
-            border='╔'
-        )
-        yield {"messages": [{"role": "assistant", "content": results[0]}]}
-        return
-
-if __name__ == "__main__":
-    import json
-    import sys
-    # print("\033[1;36m\n╔══════════════════════════════════════════════════════════════╗\n║   ✨ DIVINE CODE BLUEPRINT                                   ║\n╠══════════════════════════════════════════════════════════════╣\n║ This blueprint seeks divine inspiration for your code.       ║\n║ Try running: python blueprint_divine_code.py 'Find a bug!'   ║\n╚══════════════════════════════════════════════════════════════╝\033[0m")
-    user_input = " ".join(sys.argv[1:]) if len(sys.argv) > 1 else "Inspire me!"
-    messages = [
-        {"role": "user", "content": user_input}
-    ]
-    blueprint = DivineCodeBlueprint(blueprint_id="demo-divine-code")
-    async def run_and_print():
-        async for response in blueprint.run(messages):
-            # print(json.dumps(response, indent=2))
-            pass
-    asyncio.run(run_and_print())

swarm/blueprints/django_chat/apps.py

@@ -1,6 +0,0 @@
-from django.apps import AppConfig
-
-class DjangoChatConfig(AppConfig):
-    default_auto_field = "django.db.models.BigAutoField"
-    name = "blueprints.django_chat"
-    label = "blueprints_django_chat"

swarm/blueprints/django_chat/blueprint_django_chat.py

@@ -1,268 +0,0 @@
-"""
-Django Chat Blueprint
-
-A blueprint providing a web-based chat interface with conversation history management.
-HTTP-only; not intended for CLI use.
-"""
-
-import logging
-import sys
-import os
-from typing import Dict, Any, List
-from swarm.blueprints.common.operation_box_utils import display_operation_box
-from swarm.core.blueprint_ux import BlueprintUXImproved
-import time
-
-# --- Logging Setup ---
-def setup_logging():
-    import argparse
-    parser = argparse.ArgumentParser(add_help=False)
-    parser.add_argument('--debug', action='store_true', help='Enable debug logging')
-    args, _ = parser.parse_known_args()
-    loglevel = os.environ.get('LOGLEVEL', None)
-    if args.debug or os.environ.get('SWARM_DEBUG', '0') == '1' or (loglevel and loglevel.upper() == 'DEBUG'):
-        logging.basicConfig(level=logging.DEBUG)
-    else:
-        logging.basicConfig(level=logging.INFO)
-    return args
-
-args = setup_logging()
-
-logger = logging.getLogger(__name__)
-
-# Reject CLI execution immediately
-if __name__ == "__main__":
-    logger.info("DjangoChatBlueprint is an HTTP-only service. Access it via the web interface at /django_chat/.")
-    print("This blueprint is designed for HTTP use only. Please access it via the web server at /django_chat/", file=sys.stderr)
-    sys.stderr.flush()
-    sys.exit(1)
-
-# Django imports after CLI rejection
-os.environ.setdefault("DJANGO_SETTINGS_MODULE", "swarm.settings")
-import django
-django.setup()
-
-from django.shortcuts import render
-from django.contrib.auth.decorators import login_required
-from django.views.decorators.csrf import csrf_exempt
-from django.contrib.auth.models import User
-from swarm.models import ChatConversation, ChatMessage
-from swarm.core.blueprint_base import BlueprintBase as Blueprint
-from swarm.utils.logger_setup import setup_logger
-
-logger = setup_logger(__name__)
-
-# --- Spinner and ANSI/emoji operation box for unified UX (for CLI/dev runs) ---
-from swarm.ux.ansi_box import ansi_box
-from rich.console import Console
-from rich.style import Style
-from rich.text import Text
-import threading
-import time
-
-class DjangoChatSpinner:
-    FRAMES = [
-        "Generating.", "Generating..", "Generating...", "Running...",
-        "⠋ Generating...", "⠙ Generating...", "⠹ Generating...", "⠸ Generating...",
-        "⠼ Generating...", "⠴ Generating...", "⠦ Generating...", "⠧ Generating...",
-        "⠇ Generating...", "⠏ Generating...", "🤖 Generating...", "💡 Generating...", "✨ Generating..."
-    ]
-    SLOW_FRAME = "Generating... Taking longer than expected"
-    INTERVAL = 0.12
-    SLOW_THRESHOLD = 10  # seconds
-
-    def __init__(self):
-        self._stop_event = threading.Event()
-        self._thread = None
-        self._start_time = None
-        self.console = Console()
-        self._last_frame = None
-        self._last_slow = False
-
-    def start(self):
-        self._stop_event.clear()
-        self._start_time = time.time()
-        self._thread = threading.Thread(target=self._spin, daemon=True)
-        self._thread.start()
-
-    def _spin(self):
-        idx = 0
-        while not self._stop_event.is_set():
-            elapsed = time.time() - self._start_time
-            if elapsed > self.SLOW_THRESHOLD:
-                txt = Text(self.SLOW_FRAME, style=Style(color="yellow", bold=True))
-                self._last_frame = self.SLOW_FRAME
-                self._last_slow = True
-            else:
-                frame = self.FRAMES[idx % len(self.FRAMES)]
-                txt = Text(frame, style=Style(color="cyan", bold=True))
-                self._last_frame = frame
-                self._last_slow = False
-            self.console.print(txt, end="\r", soft_wrap=True, highlight=False)
-            time.sleep(self.INTERVAL)
-            idx += 1
-        self.console.print(" " * 40, end="\r")  # Clear line
-
-    def stop(self, final_message="Done!"):
-        self._stop_event.set()
-        if self._thread:
-            self._thread.join()
-        self.console.print(Text(final_message, style=Style(color="green", bold=True)))
-
-    def current_spinner_state(self):
-        if self._last_slow:
-            return self.SLOW_FRAME
-        return self._last_frame or self.FRAMES[0]
-
-
-class DjangoChatBlueprint(Blueprint):
-    def __init__(self, blueprint_id: str = "django_chat", config=None, config_path=None, **kwargs):
-        super().__init__(blueprint_id, config=config, config_path=config_path, **kwargs)
-        self.blueprint_id = blueprint_id
-        self.config_path = config_path
-        self._config = config if config is not None else None
-        self._llm_profile_name = None
-        self._llm_profile_data = None
-        self._markdown_output = None
-        class DummyLLM:
-            def chat_completion_stream(self, messages, **_):
-                class DummyStream:
-                    def __aiter__(self): return self
-                    async def __anext__(self):
-                        raise StopAsyncIteration
-                return DummyStream()
-        self.llm = DummyLLM()
-
-    @property
-    def metadata(self) -> Dict[str, Any]:
-        logger.debug("Fetching metadata")
-        return {
-            "title": "Django Chat Interface",
-            "description": "A web-based chat interface with conversation history management. HTTP-only.",
-            "cli_name": "django_chat",
-            "env_vars": [],
-            "urls_module": "blueprints.django_chat.urls",
-            "url_prefix": "django_chat/"
-        }
-
-    def get_or_create_default_user(self):
-        """Create or retrieve a default 'testuser' for development purposes."""
-        username = "testuser"
-        try:
-            user = User.objects.get(username=username)
-        except User.DoesNotExist:
-            user = User.objects.create_user(username=username, password="testpass")
-            logger.info(f"Created default user: {username}")
-        return user
-
-    @csrf_exempt
-    @login_required
-    def django_chat(self, request):
-        """Render the django_chat UI with user-specific conversation history."""
-        logger.debug("Rendering django_chat web UI")
-        user = request.user if request.user.is_authenticated else self.get_or_create_default_user()
-        conversations = ChatConversation.objects.filter(student=user).order_by('-created_at')
-        context = {
-            "dark_mode": request.session.get('dark_mode', True),
-            "is_chatbot": False,
-            "conversations": conversations
-        }
-        return render(request, "django_chat/django_chat_webpage.html", context)
-
-    def render_prompt(self, template_name: str, context: dict) -> str:
-        return f"User request: {context.get('user_request', '')}\nHistory: {context.get('history', '')}\nAvailable tools: {', '.join(context.get('available_tools', []))}"
-
-    async def run(self, messages: List[Dict[str, str]]):
-        """Main execution entry point for the DjangoChat blueprint."""
-        logger.info("DjangoChatBlueprint run method called.")
-        instruction = messages[-1].get("content", "") if messages else ""
-        ux = BlueprintUXImproved(style="serious")
-        spinner_idx = 0
-        start_time = time.time()
-        spinner_yield_interval = 1.0  # seconds
-        last_spinner_time = start_time
-        yielded_spinner = False
-        result_chunks = []
-        try:
-            # Simulate agent runner pattern (replace with actual agent logic if available)
-            prompt_context = {
-                "user_request": instruction,
-                "history": messages[:-1],
-                "available_tools": ["django_chat"]
-            }
-            rendered_prompt = self.render_prompt("django_chat_prompt.j2", prompt_context)
-            # Simulate progressive spinner for a few cycles
-            for _ in range(3):
-                now = time.time()
-                if now - last_spinner_time >= spinner_yield_interval:
-                    taking_long = (now - start_time > 10)
-                    spinner_msg = ux.spinner(spinner_idx, taking_long=taking_long)
-                    yield {"messages": [{"role": "assistant", "content": spinner_msg}]}
-                    spinner_idx += 1
-                    last_spinner_time = now
-                    yielded_spinner = True
-                    await asyncio.sleep(0.2)
-            # Final result
-            summary = ux.summary("Operation", 1, {"instruction": instruction[:40]})
-            box = ux.ansi_emoji_box(
-                title="DjangoChat Result",
-                content=f"[DjangoChat LLM] Would respond to: {rendered_prompt}",
-                summary=summary,
-                params={"instruction": instruction[:40]},
-                result_count=1,
-                op_type="run",
-                status="success"
-            )
-            yield {"messages": [{"role": "assistant", "content": box}]}
-        except Exception as e:
-            logger.error(f"Error during DjangoChat run: {e}", exc_info=True)
-            yield {"messages": [{"role": "assistant", "content": f"An error occurred: {e}"}]}
-
-    def run_with_context(self, messages: List[Dict[str, str]], context_variables: dict) -> dict:
-        """Minimal implementation for CLI compatibility without agents."""
-        logger.debug("Running with context (UI-focused implementation)")
-        return {
-            "response": {"messages": [{"role": "assistant", "content": "Django Chat UI active via web interface at /django_chat/"}]},
-            "context_variables": context_variables
-        }
-
-if __name__ == "__main__":
-    import asyncio
-    import json
-    messages = [
-        {"role": "user", "content": "Start a chat session about Django."}
-    ]
-    blueprint = DjangoChatBlueprint(blueprint_id="demo-1")
-    async def run_and_print():
-        spinner = DjangoChatSpinner()
-        spinner.start()
-        try:
-            all_results = []
-            async for response in blueprint.run(messages):
-                content = response["messages"][0]["content"] if (isinstance(response, dict) and "messages" in response and response["messages"]) else str(response)
-                all_results.append(content)
-                # Enhanced progressive output
-                if isinstance(response, dict) and (response.get("progress") or response.get("matches")):
-                    display_operation_box(
-                        title="Progressive Operation",
-                        content="\n".join(response.get("matches", [])),
-                        style="bold cyan" if response.get("type") == "code_search" else "bold magenta",
-                        result_count=len(response.get("matches", [])) if response.get("matches") is not None else None,
-                        params={k: v for k, v in response.items() if k not in {'matches', 'progress', 'total', 'truncated', 'done'}},
-                        progress_line=response.get('progress'),
-                        total_lines=response.get('total'),
-                        spinner_state=spinner.current_spinner_state() if hasattr(spinner, 'current_spinner_state') else None,
-                        op_type=response.get("type", "search"),
-                        emoji="🔍" if response.get("type") == "code_search" else "🧠"
-                    )
-        finally:
-            spinner.stop()
-        display_operation_box(
-            title="DjangoChat Output",
-            content="\n".join(all_results),
-            style="bold green",
-            result_count=len(all_results),
-            params={"prompt": messages[0]["content"]},
-            op_type="django_chat"
-        )
-    asyncio.run(run_and_print())

swarm/blueprints/django_chat/templates/django_chat/django_chat_webpage.html

@@ -1,37 +0,0 @@
-<div x-data="{ open: false, selectedModel: '', models: [] }" class="relative w-72 mx-auto mt-5">
-    <!-- Dropdown Trigger -->
-    <button 
-        @click="open = !open" 
-        class="w-full px-4 py-2 text-left bg-white border border-gray-300 rounded-md shadow-sm focus:ring focus:ring-blue-500"
-    >
-        <span x-text="selectedModel ? selectedModel : 'Select a Model'"></span>
-        <svg xmlns="http://www.w3.org/2000/svg" class="w-5 h-5 inline float-right" fill="none" viewBox="0 0 24 24" stroke="currentColor">
-            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7" />
-        </svg>
-    </button>
-
-    <!-- Dropdown Options -->
-    <div 
-        x-show="open" 
-        @click.outside="open = false" 
-        class="absolute z-10 w-full mt-2 bg-white border border-gray-300 rounded-md shadow-lg max-h-60 overflow-auto"
-    >
-        <!-- Fetch models with HTMX -->
-        <div hx-get="/v1/models" hx-trigger="load" hx-target="#model-list" hx-swap="innerHTML">
-            <p class="px-4 py-2 text-gray-500">Loading models...</p>
-        </div>
-
-        <!-- Render Models -->
-        <div id="model-list">
-            <template x-for="model in models" :key="model.id">
-                <div 
-                    @click="selectedModel = model.name; open = false"
-                    class="px-4 py-2 cursor-pointer hover:bg-blue-100"
-                >
-                    <p class="text-sm font-medium" x-text="model.name"></p>
-                    <p class="text-xs text-gray-500" x-text="model.description"></p>
-                </div>
-            </template>
-        </div>
-    </div>
-</div>

swarm/blueprints/django_chat/urls.py

@@ -1,8 +0,0 @@
-from django.urls import path
-from . import views
-
-app_name = "django_chat"
-
-urlpatterns = [
-    path('', views.django_chat, name='django_chat'),
-]

swarm/blueprints/django_chat/views.py

@@ -1,32 +0,0 @@
-from django.shortcuts import render
-from django.contrib.auth.decorators import login_required
-from django.views.decorators.csrf import csrf_exempt
-from django.contrib.auth.models import User
-from swarm.models import ChatConversation, ChatMessage
-from swarm.utils.logger_setup import setup_logger
-
-logger = setup_logger(__name__)
-
-def get_or_create_default_user():
-    """Create or retrieve a default 'testuser' for development purposes."""
-    username = "testuser"
-    try:
-        user = User.objects.get(username=username)
-    except User.DoesNotExist:
-        user = User.objects.create_user(username=username, password="testpass")
-        logger.info(f"Created default user: {username}")
-    return user
-
-@csrf_exempt
-@login_required
-def django_chat(request):
-    """Render the django_chat UI with user-specific conversation history."""
-    logger.debug("Rendering django_chat web UI")
-    user = request.user if request.user.is_authenticated else get_or_create_default_user()
-    conversations = ChatConversation.objects.filter(student=user).order_by('-created_at')
-    context = {
-        "dark_mode": request.session.get('dark_mode', True),
-        "is_chatbot": False,
-        "conversations": conversations
-    }
-    return render(request, "django_chat/django_chat_webpage.html", context)