⭐️ Comming soon pages

Author: Phinease

agent_market_server/crud.py

@@ -0,0 +1,232 @@
+"""
+CRUD operations for Agent Market Server
+"""
+import logging
+from typing import List, Dict, Any, Optional, Tuple
+
+from sqlalchemy import func
+from sqlalchemy.orm import Session, joinedload
+
+from database import get_db_session, as_dict
+from models import MarketAgent, MarketTool, MarketMcpServer, MarketAgentToolRel, MarketAgentMcpRel
+
+logger = logging.getLogger("crud")
+
+
+def get_agent_list(
+    page: int = 1,
+    page_size: int = 20,
+    enabled_only: bool = True
+) -> Tuple[List[Dict[str, Any]], int]:
+    """
+    Get paginated list of agents
+    
+    Args:
+        page: Page number (starts from 1)
+        page_size: Number of items per page
+        enabled_only: If True, only return enabled agents
+        
+    Returns:
+        Tuple of (agent_list, total_count)
+    """
+    with get_db_session() as session:
+        query = session.query(MarketAgent).filter(MarketAgent.delete_flag != 'Y')
+        
+        if enabled_only:
+            query = query.filter(MarketAgent.enabled == True)
+        
+        # Get total count
+        total = query.count()
+        
+        # Apply pagination
+        offset = (page - 1) * page_size
+        agents = query.order_by(MarketAgent.create_time.desc()).offset(offset).limit(page_size).all()
+        
+        # Convert to list format with basic info
+        agent_list = []
+        for agent in agents:
+            agent_list.append({
+                "agent_id": agent.agent_id,
+                "name": agent.name,
+                "display_name": agent.display_name,
+                "description": agent.description,
+                "logo_url": agent.logo_url,
+                "enabled": agent.enabled,
+                "create_time": agent.create_time.isoformat() if agent.create_time else None
+            })
+        
+        return agent_list, total
+
+
+def get_agent_detail(agent_id: int) -> Optional[Dict[str, Any]]:
+    """
+    Get detailed information for a specific agent
+    
+    Args:
+        agent_id: Agent ID
+        
+    Returns:
+        Dictionary with agent details including tools and MCP servers
+    """
+    with get_db_session() as session:
+        agent = session.query(MarketAgent).options(
+            joinedload(MarketAgent.tools).joinedload(MarketAgentToolRel.tool),
+            joinedload(MarketAgent.mcps).joinedload(MarketAgentMcpRel.mcp)
+        ).filter(
+            MarketAgent.agent_id == agent_id,
+            MarketAgent.delete_flag != 'Y'
+        ).first()
+        
+        if not agent:
+            return None
+        
+        # Build agent info dict
+        agent_info = as_dict(agent)
+        
+        # Add tools information
+        tools = []
+        for rel in agent.tools:
+            if rel.delete_flag != 'Y' and rel.tool.delete_flag != 'Y':
+                tool_dict = as_dict(rel.tool)
+                # Map tool_metadata back to metadata for API compatibility
+                if 'tool_metadata' in tool_dict:
+                    tool_dict['metadata'] = tool_dict.pop('tool_metadata')
+                tools.append(tool_dict)
+        
+        agent_info['tools'] = tools
+        
+        # Add MCP servers information
+        mcp_info = []
+        for rel in agent.mcps:
+            if rel.delete_flag != 'Y' and rel.mcp.delete_flag != 'Y':
+                mcp_dict = {
+                    "mcp_server_name": rel.mcp.mcp_server_name,
+                    "mcp_url": rel.mcp.mcp_url
+                }
+                mcp_info.append(mcp_dict)
+        
+        agent_info['mcp_info'] = mcp_info
+        
+        # Add managed_agents (empty list for compatibility)
+        agent_info['managed_agents'] = []
+        
+        return agent_info
+
+
+def create_agent_with_relations(agent_data: Dict[str, Any]) -> int:
+    """
+    Create a new agent with tools and MCP server relationships
+    
+    Args:
+        agent_data: Dictionary containing agent information, tools, and mcp_info
+        
+    Returns:
+        Created agent ID
+    """
+    with get_db_session() as session:
+        # Extract tools and mcp_info
+        tools_data = agent_data.pop('tools', [])
+        mcp_info_data = agent_data.pop('mcp_info', [])
+        agent_data.pop('managed_agents', None)  # Remove if exists
+        
+        # Create agent
+        agent = MarketAgent(**agent_data)
+        agent.delete_flag = 'N'
+        session.add(agent)
+        session.flush()
+        
+        agent_id = agent.agent_id
+        
+        # Create tools and relationships
+        for tool_data in tools_data:
+            # Check if tool already exists by name and class_name
+            existing_tool = session.query(MarketTool).filter(
+                MarketTool.name == tool_data['name'],
+                MarketTool.class_name == tool_data['class_name'],
+                MarketTool.delete_flag != 'Y'
+            ).first()
+            
+            if existing_tool:
+                tool_id = existing_tool.tool_id
+            else:
+                # Create new tool
+                tool = MarketTool(
+                    name=tool_data['name'],
+                    class_name=tool_data['class_name'],
+                    description=tool_data.get('description'),
+                    inputs=tool_data.get('inputs'),
+                    output_type=tool_data.get('output_type'),
+                    source=tool_data.get('source'),
+                    usage=tool_data.get('usage'),
+                    params=tool_data.get('params'),
+                    tool_metadata=tool_data.get('metadata'),
+                    delete_flag='N'
+                )
+                session.add(tool)
+                session.flush()
+                tool_id = tool.tool_id
+            
+            # Create relationship
+            rel = MarketAgentToolRel(
+                agent_id=agent_id,
+                tool_id=tool_id,
+                delete_flag='N'
+            )
+            session.add(rel)
+        
+        # Create MCP servers and relationships
+        for mcp_data in mcp_info_data:
+            # Check if MCP server already exists by name and URL
+            existing_mcp = session.query(MarketMcpServer).filter(
+                MarketMcpServer.mcp_server_name == mcp_data['mcp_server_name'],
+                MarketMcpServer.mcp_url == mcp_data['mcp_url'],
+                MarketMcpServer.delete_flag != 'Y'
+            ).first()
+            
+            if existing_mcp:
+                mcp_id = existing_mcp.mcp_id
+            else:
+                # Create new MCP server
+                mcp = MarketMcpServer(
+                    mcp_server_name=mcp_data['mcp_server_name'],
+                    mcp_url=mcp_data['mcp_url'],
+                    delete_flag='N'
+                )
+                session.add(mcp)
+                session.flush()
+                mcp_id = mcp.mcp_id
+            
+            # Create relationship
+            rel = MarketAgentMcpRel(
+                agent_id=agent_id,
+                mcp_id=mcp_id,
+                delete_flag='N'
+            )
+            session.add(rel)
+        
+        session.commit()
+        return agent_id
+
+
+def delete_agent(agent_id: int) -> bool:
+    """
+    Soft delete an agent
+    
+    Args:
+        agent_id: Agent ID to delete
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    with get_db_session() as session:
+        agent = session.query(MarketAgent).filter(
+            MarketAgent.agent_id == agent_id
+        ).first()
+        
+        if not agent:
+            return False
+        
+        agent.delete_flag = 'Y'
+        session.commit()
+        return True
+

agent_market_server/database.py

@@ -0,0 +1,163 @@
+"""
+Database client and connection management for Agent Market Server
+"""
+import logging
+from contextlib import contextmanager
+from datetime import datetime, date
+from typing import Optional, Any
+from urllib.parse import quote_plus
+
+import yaml
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, class_mapper
+from sqlalchemy.sql.schema import MetaData
+
+from models import Base
+
+logger = logging.getLogger("database")
+
+
+class DatabaseConfig:
+    """Database configuration loader"""
+
+    def __init__(self, config_path: str = "config.yaml"):
+        with open(config_path, 'r') as f:
+            config = yaml.safe_load(f)
+            db_config = config['database']
+
+        self.host = db_config['host']
+        self.port = db_config['port']
+        self.user = db_config['user']
+        self.password = db_config['password']
+        self.database = db_config['database']
+        self.schema = db_config.get('schema', 'agent_market')
+        self.pool_size = db_config.get('pool_size', 10)
+        self.pool_timeout = db_config.get('pool_timeout', 30)
+
+    def get_connection_url(self) -> str:
+        """Get SQLAlchemy connection URL"""
+        # URL encode password to handle special characters like @, :, /, etc.
+        encoded_password = quote_plus(self.password)
+        return f"postgresql://{self.user}:{encoded_password}@{self.host}:{self.port}/{self.database}"
+
+
+class DatabaseClient:
+    """PostgreSQL database client singleton"""
+    _instance: Optional['DatabaseClient'] = None
+    _engine = None
+    _session_maker = None
+
+    def __new__(cls, config_path: str = "config.yaml"):
+        if cls._instance is None:
+            cls._instance = super(DatabaseClient, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self, config_path: str = "config.yaml"):
+        if self._engine is None:
+            self.config = DatabaseConfig(config_path)
+            self._initialize_engine()
+
+    def _initialize_engine(self):
+        """Initialize SQLAlchemy engine and session maker"""
+        self._engine = create_engine(
+            self.config.get_connection_url(),
+            pool_size=self.config.pool_size,
+            pool_pre_ping=True,
+            pool_timeout=self.config.pool_timeout,
+            echo=False
+        )
+        self._session_maker = sessionmaker(bind=self._engine)
+        logger.info("Database engine initialized successfully")
+
+    @property
+    def engine(self):
+        """Get SQLAlchemy engine"""
+        return self._engine
+
+    @property
+    def session_maker(self):
+        """Get session maker"""
+        return self._session_maker
+
+    def create_tables(self):
+        """Create all tables defined in models"""
+        Base.metadata.create_all(self._engine)
+        logger.info("Database tables created successfully")
+
+
+# Global database client instance
+db_client = DatabaseClient()
+
+
+@contextmanager
+def get_db_session(db_session=None):
+    """
+    Provide a transactional scope around a series of operations.
+    
+    Args:
+        db_session: Optional existing session to use
+        
+    Yields:
+        SQLAlchemy session object
+    """
+    session = db_client.session_maker() if db_session is None else db_session
+    try:
+        yield session
+        if db_session is None:
+            session.commit()
+    except Exception as e:
+        if db_session is None:
+            session.rollback()
+        logger.error(f"Database operation failed: {str(e)}")
+        raise e
+    finally:
+        if db_session is None:
+            session.close()
+
+
+def as_dict(obj):
+    """
+    Convert SQLAlchemy model instance to dictionary
+    
+    Args:
+        obj: SQLAlchemy model instance
+        
+    Returns:
+        Dictionary representation of the model with serializable values
+    """
+    if hasattr(obj, '__table__'):
+        result = {}
+        mapper = class_mapper(obj.__class__)
+        for c in mapper.columns:
+            key = c.key
+            try:
+                value = getattr(obj, key)
+                # Skip SQLAlchemy internal objects like MetaData
+                if isinstance(value, MetaData):
+                    continue
+                # Convert datetime objects to ISO format strings
+                if isinstance(value, (datetime, date)):
+                    result[key] = value.isoformat() if value else None
+                else:
+                    result[key] = value
+            except AttributeError:
+                # Skip if attribute doesn't exist
+                continue
+        return result
+    return dict(obj._mapping)
+
+
+def filter_property(data: dict, model_class):
+    """
+    Filter dictionary to only include keys that match model columns
+    
+    Args:
+        data: Dictionary to filter
+        model_class: SQLAlchemy model class
+        
+    Returns:
+        Filtered dictionary with only valid column keys
+    """
+    model_fields = model_class.__table__.columns.keys()
+    return {key: value for key, value in data.items() if key in model_fields}
+