lybic-guiagents 0.1.0__py3-none-any.whl

gui_agents/utils/display_viewer.py

@@ -0,0 +1,281 @@
+#!/usr/bin/env python
+"""
+Display Viewer - Used to display operation records in display.json file in chronological order
+
+Usage:
+    python -m lybicguiagents.gui_agents.utils.display_viewer --file /path/to/display.json [--output text|json] [--filter module1,module2]
+"""
+
+import os
+import sys
+import json
+import argparse
+import datetime
+from pathlib import Path
+from typing import Dict, List, Any, Optional, Tuple
+
+
+def load_display_json(file_path: str) -> Dict:
+    """
+    Load display.json file
+    
+    Args:
+        file_path: Path to display.json file
+        
+    Returns:
+        Parsed JSON data
+    """
+    try:
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except UnicodeDecodeError:
+            print(
+                f"Warning: Failed to decode '{file_path}' with utf-8, retrying with GB2312..."
+            )
+            with open(file_path, 'r', encoding='gb2312') as f:
+                return json.load(f)
+    except FileNotFoundError:
+        print(f"Error: File '{file_path}' does not exist")
+        sys.exit(1)
+    except json.JSONDecodeError:
+        print(f"Error: File '{file_path}' is not a valid JSON format")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: An error occurred while reading file '{file_path}': {e}")
+        sys.exit(1)
+
+
+def flatten_operations(data: Dict) -> List[Dict]:
+    """
+    Flatten all module operation records into a time-sorted list
+    
+    Args:
+        data: display.json data
+        
+    Returns:
+        List of operation records sorted by time
+    """
+    all_operations = []
+
+    if "operations" not in data:
+        return all_operations
+
+    for module, operations in data["operations"].items():
+        for op in operations:
+            # Add module information
+            op["module"] = module
+            all_operations.append(op)
+
+    # Sort by timestamp
+    all_operations.sort(key=lambda x: x.get("timestamp", 0))
+
+    return all_operations
+
+
+def format_timestamp(timestamp: float) -> str:
+    """
+    Format timestamp into readable datetime
+    
+    Args:
+        timestamp: UNIX timestamp
+        
+    Returns:
+        Formatted datetime string
+    """
+    dt = datetime.datetime.fromtimestamp(timestamp)
+    return dt.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+
+
+def format_duration(duration: float) -> str:
+    """
+    Format duration
+    
+    Args:
+        duration: Duration (seconds)
+        
+    Returns:
+        Formatted duration string
+    """
+    if duration < 0.001:
+        return f"{duration * 1000000:.2f}μs"
+    elif duration < 1:
+        return f"{duration * 1000:.2f}ms"
+    else:
+        return f"{duration:.2f}s"
+
+
+def format_tokens(tokens: List[int]) -> str:
+    """
+    Format tokens information
+    
+    Args:
+        tokens: [input tokens, output tokens, total tokens]
+        
+    Returns:
+        Formatted tokens string
+    """
+    if not tokens or len(tokens) < 3:
+        return "N/A"
+
+    return f"in:{tokens[0]} out:{tokens[1]} total:{tokens[2]}"
+
+
+def truncate_text(text: str, max_length: int = 100) -> str:
+    """
+    Truncate text, add ellipsis when exceeding maximum length
+    
+    Args:
+        text: Original text
+        max_length: Maximum length
+        
+    Returns:
+        Truncated text
+    """
+    if not text:
+        return ""
+
+    if isinstance(text, (dict, list)):
+        text = str(text)
+
+    if len(text) <= max_length:
+        return text
+
+    return text[:max_length - 3] + "..."
+
+
+def find_latest_display_json() -> Optional[str]:
+    """
+    Find the latest display.json file
+    
+    Returns:
+        Path to the latest display.json file, or None if not found
+    """
+    # Look for the runtime folder in the current directory
+    runtime_dir = Path("runtime")
+    if not runtime_dir.exists() or not runtime_dir.is_dir():
+        # Try looking in the parent directory
+        parent_runtime = Path("..") / "runtime"
+        if parent_runtime.exists() and parent_runtime.is_dir():
+            runtime_dir = parent_runtime
+        else:
+            return None
+
+    # Find all timestamp folders
+    timestamp_dirs = [d for d in runtime_dir.iterdir() if d.is_dir()]
+    if not timestamp_dirs:
+        return None
+
+    # Sort by folder name (timestamp) and take the latest
+    latest_dir = sorted(timestamp_dirs)[-1]
+    display_file = latest_dir / "display.json"
+
+    if display_file.exists():
+        return str(display_file)
+
+    return None
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=
+        "Display operation records in display.json file in chronological order")
+    parser.add_argument("--file", help="Path to display.json file")
+    parser.add_argument("--dir", help="Path to directory containing display.json files (recursive)")
+    parser.add_argument("--output",
+                        choices=["text", "json"],
+                        default="text",
+                        help="Output format (default: text)")
+    parser.add_argument(
+        "--filter",
+        help="Modules to filter, separated by commas (e.g., manager,worker)")
+
+    args = parser.parse_args()
+
+    if args.file and args.dir:
+        print("Error: --file and --dir cannot be used together")
+        sys.exit(1)
+
+    def process_one_file(file_path: str):
+        # Load data
+        data = load_display_json(file_path)
+        # Flatten and sort operations
+        operations = flatten_operations(data)
+        # Handle module filtering
+        filter_modules = None
+        if args.filter:
+            filter_modules = [module.strip() for module in args.filter.split(",")]
+        # Generate output content
+        output_content = ""
+        if args.output == "json":
+            # Filter operations if modules are specified
+            if filter_modules:
+                filtered_ops = [op for op in operations if op["module"] in filter_modules]
+            else:
+                filtered_ops = operations
+            output_content = json.dumps(filtered_ops, indent=2, ensure_ascii=False)
+        else:
+            # Generate text format output
+            output_lines = []
+            for i, op in enumerate(operations):
+                # Skip modules that don't match the filter if a filter is specified
+                if filter_modules and op["module"] not in filter_modules:
+                    continue
+                module = op["module"]
+                operation = op.get("operation", "unknown")
+                timestamp = format_timestamp(op.get("timestamp", 0))
+                # Output basic information
+                output_lines.append(f"{i+1:3d} | {timestamp} | {module:10} | {operation}")
+                # Output detailed information
+                if "duration" in op:
+                    output_lines.append(f"     └─ Duration: {format_duration(op['duration'])}")
+                if "tokens" in op:
+                    output_lines.append(f"     └─ Tokens: {format_tokens(op['tokens'])}")
+                if "cost" in op:
+                    output_lines.append(f"     └─ Cost: {op['cost']}")
+                if "content" in op:
+                    content = op["content"]
+                    output_lines.append(f"     └─ Content: {content}")
+                if "status" in op:
+                    output_lines.append(f"     └─ Status: {op['status']}")
+                output_lines.append("")
+            output_content = "\n".join(output_lines)
+        # Write output to file
+        input_path = Path(file_path)
+        output_filename = f"display_viewer_output_{args.output}.txt"
+        output_path = input_path.parent / output_filename
+        try:
+            with open(output_path, 'w', encoding='utf-8') as f:
+                f.write(output_content)
+            print(f"Output written to: {output_path}")
+        except Exception as e:
+            print(f"Error writing output file: {e}")
+            sys.exit(1)
+
+    if args.dir:
+        for root, dirs, files in os.walk(args.dir):
+            for file in files:
+                if file == "display.json":
+                    file_path = os.path.join(root, file)
+                    print(f"Processing: {file_path}")
+                    process_one_file(file_path)
+        return
+
+    file_path = args.file
+    if not file_path:
+        file_path = find_latest_display_json()
+        if not file_path:
+            print(
+                "Error: Cannot find display.json file, please specify file path using --file parameter"
+            )
+            sys.exit(1)
+        print(f"Using the latest display.json file: {file_path}")
+    process_one_file(file_path)
+
+
+if __name__ == "__main__":
+    """
+    python display_viewer.py --file 
+    python display_viewer.py --dir 
+    """
+    main()

gui_agents/utils/embedding_manager.py

@@ -0,0 +1,53 @@
+import numpy as np
+from gui_agents.utils.common_utils import (
+    load_embeddings,
+    save_embeddings,
+)
+import os
+
+# List all embeddings' keys and their shapes
+def list_embeddings(embeddings_path: str):
+    if not os.path.exists(embeddings_path):
+        print(f"[EmbeddingManager] File not found: {embeddings_path}")
+        return {}
+    embeddings = load_embeddings(embeddings_path)
+    info = {}
+    for k, v in embeddings.items():
+        arr = np.array(v)
+        info[k] = {'shape': arr.shape, 'preview': arr.flatten()[:5].tolist()}
+    return info
+
+# Delete a specific embedding by key
+def delete_embedding(embeddings_path: str, key: str) -> bool:
+    if not os.path.exists(embeddings_path):
+        print(f"[EmbeddingManager] File not found: {embeddings_path}")
+        return False
+    embeddings = load_embeddings(embeddings_path)
+    if key not in embeddings:
+        print(f"[EmbeddingManager] Key not found: {key}")
+        return False
+    del embeddings[key]
+    save_embeddings(embeddings_path, embeddings)
+    print(f"[EmbeddingManager] Deleted embedding for key: {key}")
+    return True
+
+def delete_empty_shape_embeddings(embeddings_path: str) -> int:
+    """Delete all embeddings whose value is empty (shape==0), shape==(), or content is error string, and return the number deleted."""
+    if not os.path.exists(embeddings_path):
+        print(f"[EmbeddingManager] File not found: {embeddings_path}")
+        return 0
+    embeddings = load_embeddings(embeddings_path)
+    to_delete = []
+    for k, v in embeddings.items():
+        arr = np.array(v)
+        # Delete shape==0 or shape==() or content is string/error information
+        if arr.size == 0 or arr.shape == () or (
+            isinstance(v, list) and v and isinstance(v[0], str) and v[0].startswith('Error:')
+        ) or (isinstance(v, str) and v.startswith('Error:')):
+            to_delete.append(k)
+    for k in to_delete:
+        del embeddings[k]
+        print(f"[EmbeddingManager] Deleted empty or error embedding for key: {k}")
+    if to_delete:
+        save_embeddings(embeddings_path, embeddings)
+    return len(to_delete) 

gui_agents/utils/image_axis_utils.py

@@ -0,0 +1,27 @@
+from PIL import Image
+
+
+def pad_to_square(image: Image.Image,
+                  fill_color=(0, 0, 0),
+                  padding: int = 0) -> Image.Image:
+    """
+    先补成正方形，再在四周扩展padding像素。
+    """
+    width, height = image.size
+    if width == height:
+        square_img = image.copy()
+    else:
+        new_size = max(width, height)
+        square_img = Image.new(image.mode, (new_size, new_size), fill_color)
+        left = (new_size - width) // 2
+        top = (new_size - height) // 2
+        square_img.paste(image, (left, top))
+
+    if padding > 0:
+        final_size = square_img.size[0] + 2 * padding
+        padded_img = Image.new(square_img.mode, (final_size, final_size),
+                               fill_color)
+        padded_img.paste(square_img, (padding, padding))
+        return padded_img
+    else:
+        return square_img