python-alfresco-api 1.0.0__py3-none-any.whl

python_alfresco_api/clients/search_sql_client.py

@@ -0,0 +1,85 @@
+"""
+AlfrescoSearchSqlClient - Individual client for Alfresco SEARCH_SQL API
+
+Wraps the generated HTTP client with enhanced functionality:
+- Automatic authentication handling
+- Pydantic model integration
+- Async/sync support
+- Error handling
+"""
+
+import sys
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+# Add raw client to path
+raw_client_path = Path(__file__).parent.parent / "raw_clients" / "alfresco_search_sql_client"
+if raw_client_path.exists():
+    # Find the actual package directory
+    package_dirs = [d for d in raw_client_path.iterdir() if d.is_dir() and not d.name.startswith('.')]
+    if package_dirs:
+        sys.path.insert(0, str(package_dirs[0]))
+
+class AlfrescoSearchSqlClient:
+    """
+    Individual client for Alfresco SEARCH_SQL API.
+    
+    Features:
+    - Uses generated HTTP client internally
+    - Automatic authentication with AuthUtil
+    - Pydantic model integration
+    - Both sync and async methods
+    """
+    
+    def __init__(
+        self,
+        base_url: str,
+        auth_util: Optional[Any] = None,
+        verify_ssl: bool = True,
+        timeout: int = 30
+    ):
+        """
+        Initialize search_sql client.
+        
+        Args:
+            base_url: Base URL of Alfresco instance
+            auth_util: Optional AuthUtil instance for authentication
+            verify_ssl: Whether to verify SSL certificates
+            timeout: Request timeout in seconds
+        """
+        self.base_url = base_url.rstrip('/')
+        self.auth_util = auth_util
+        self.verify_ssl = verify_ssl
+        self.timeout = timeout
+        
+        # Initialize the generated client
+        self._init_generated_client()
+    
+    def _init_generated_client(self):
+        """Initialize the generated HTTP client"""
+        try:
+            from client import Client
+            self.client = Client(base_url=self.base_url)
+            self._client_available = True
+        except ImportError as e:
+            print(f"⚠️  Generated client not available for search_sql: {e}")
+            self.client = None
+            self._client_available = False
+    
+    def is_available(self) -> bool:
+        """Check if the generated client is available"""
+        return self._client_available
+    
+    async def _ensure_auth(self):
+        """Ensure authentication before API calls"""
+        if self.auth_util:
+            await self.auth_util.ensure_authenticated()
+    
+    def get_client_info(self) -> Dict[str, Any]:
+        """Get information about this client"""
+        return {
+            "api": "search_sql",
+            "base_url": self.base_url,
+            "authenticated": self.auth_util.is_authenticated() if self.auth_util else False,
+            "client_available": self._client_available
+        }

python_alfresco_api/clients/workflow_client.py

@@ -0,0 +1,85 @@
+"""
+AlfrescoWorkflowClient - Individual client for Alfresco WORKFLOW API
+
+Wraps the generated HTTP client with enhanced functionality:
+- Automatic authentication handling
+- Pydantic model integration
+- Async/sync support
+- Error handling
+"""
+
+import sys
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+# Add raw client to path
+raw_client_path = Path(__file__).parent.parent / "raw_clients" / "alfresco_workflow_client"
+if raw_client_path.exists():
+    # Find the actual package directory
+    package_dirs = [d for d in raw_client_path.iterdir() if d.is_dir() and not d.name.startswith('.')]
+    if package_dirs:
+        sys.path.insert(0, str(package_dirs[0]))
+
+class AlfrescoWorkflowClient:
+    """
+    Individual client for Alfresco WORKFLOW API.
+    
+    Features:
+    - Uses generated HTTP client internally
+    - Automatic authentication with AuthUtil
+    - Pydantic model integration
+    - Both sync and async methods
+    """
+    
+    def __init__(
+        self,
+        base_url: str,
+        auth_util: Optional[Any] = None,
+        verify_ssl: bool = True,
+        timeout: int = 30
+    ):
+        """
+        Initialize workflow client.
+        
+        Args:
+            base_url: Base URL of Alfresco instance
+            auth_util: Optional AuthUtil instance for authentication
+            verify_ssl: Whether to verify SSL certificates
+            timeout: Request timeout in seconds
+        """
+        self.base_url = base_url.rstrip('/')
+        self.auth_util = auth_util
+        self.verify_ssl = verify_ssl
+        self.timeout = timeout
+        
+        # Initialize the generated client
+        self._init_generated_client()
+    
+    def _init_generated_client(self):
+        """Initialize the generated HTTP client"""
+        try:
+            from client import Client
+            self.client = Client(base_url=self.base_url)
+            self._client_available = True
+        except ImportError as e:
+            print(f"⚠️  Generated client not available for workflow: {e}")
+            self.client = None
+            self._client_available = False
+    
+    def is_available(self) -> bool:
+        """Check if the generated client is available"""
+        return self._client_available
+    
+    async def _ensure_auth(self):
+        """Ensure authentication before API calls"""
+        if self.auth_util:
+            await self.auth_util.ensure_authenticated()
+    
+    def get_client_info(self) -> Dict[str, Any]:
+        """Get information about this client"""
+        return {
+            "api": "workflow",
+            "base_url": self.base_url,
+            "authenticated": self.auth_util.is_authenticated() if self.auth_util else False,
+            "client_available": self._client_available
+        }

python_alfresco_api/events/__init__.py

@@ -0,0 +1,15 @@
+"""
+Alfresco Event System
+
+Unified event client supporting both Community Edition (ActiveMQ) and Enterprise Edition (Event Gateway).
+Provides automatic detection and graceful fallback capabilities.
+"""
+
+from .event_client import AlfrescoEventClient
+from .models import EventSubscription, EventNotification
+
+__all__ = [
+    "AlfrescoEventClient",
+    "EventSubscription", 
+    "EventNotification"
+] 

python_alfresco_api/events/event_client.py

@@ -0,0 +1,268 @@
+"""
+Unified Alfresco Event Client
+
+Supports both Community Edition (ActiveMQ/STOMP) and Enterprise Edition (Event Gateway/REST).
+Features automatic detection and graceful fallback capabilities.
+"""
+
+import asyncio
+import logging
+from typing import Any, Callable, Dict, List, Optional, Union
+
+try:
+    import stomp
+    STOMP_AVAILABLE = True
+except ImportError:
+    STOMP_AVAILABLE = False
+
+try:
+    import httpx
+    HTTPX_AVAILABLE = True
+except ImportError:
+    HTTPX_AVAILABLE = False
+
+from .models import EventSubscription, EventNotification
+
+
+logger = logging.getLogger(__name__)
+
+
+class AlfrescoEventClient:
+    """
+    Unified Alfresco Event Client
+    
+    Automatically detects and supports both:
+    - Community Edition: ActiveMQ (port 61616) with STOMP protocol
+    - Enterprise Edition: Event Gateway (port 7070) with REST API
+    """
+    
+    def __init__(
+        self,
+        alfresco_host: str = "localhost",
+        username: str = "admin",
+        password: str = "admin",
+        community_port: int = 61616,
+        enterprise_port: int = 7070,
+        auto_detect: bool = True,
+        debug: bool = False
+    ):
+        self.alfresco_host = alfresco_host
+        self.username = username
+        self.password = password
+        self.community_port = community_port
+        self.enterprise_port = enterprise_port
+        self.debug = debug
+        
+        # Detection results
+        self.event_gateway_available = False
+        self.activemq_available = False
+        self.event_system: Optional[str] = None  # 'enterprise', 'community', or None
+        
+        # Event handlers
+        self.event_handlers: Dict[str, List[Callable]] = {}
+        
+        # STOMP connection (Community Edition)
+        self.stomp_connection = None
+        
+        # HTTP client (Enterprise Edition)
+        self.http_client = None
+        
+        if auto_detect:
+            # Start detection in background
+            asyncio.create_task(self._detect_event_systems())
+    
+    async def _detect_event_systems(self):
+        """Detect available event systems"""
+        await asyncio.gather(
+            self._check_event_gateway(),
+            self._check_activemq(),
+            return_exceptions=True
+        )
+        
+        # Determine active system (Enterprise takes priority)
+        if self.event_gateway_available:
+            self.event_system = "enterprise"
+        elif self.activemq_available:
+            self.event_system = "community"
+        else:
+            self.event_system = None
+            
+        if self.debug:
+            logger.info(f"Event system detection complete: {self.event_system}")
+    
+    async def _check_event_gateway(self):
+        """Check Enterprise Event Gateway availability"""
+        if not HTTPX_AVAILABLE:
+            return
+            
+        try:
+            url = f"http://{self.alfresco_host}:{self.enterprise_port}/alfresco/api/-default-/private/alfresco/versions/1/event-subscriptions"
+            
+            async with httpx.AsyncClient() as client:
+                response = await client.get(url, timeout=5.0)
+                self.event_gateway_available = response.status_code in [200, 401, 403]
+                
+        except Exception as e:
+            if self.debug:
+                logger.debug(f"Event Gateway check failed: {e}")
+            self.event_gateway_available = False
+    
+    async def _check_activemq(self):
+        """Check Community ActiveMQ availability"""
+        if not STOMP_AVAILABLE:
+            self.activemq_available = False
+            return
+            
+        try:
+            # Test STOMP connection
+            conn = stomp.Connection([(self.alfresco_host, self.community_port)])
+            conn.connect(self.username, self.password, wait=False)
+            conn.disconnect()
+            self.activemq_available = True
+            
+        except Exception as e:
+            if self.debug:
+                logger.debug(f"ActiveMQ check failed: {e}")
+            self.activemq_available = False
+    
+    def get_system_info(self) -> Dict[str, Any]:
+        """Get event system detection information"""
+        return {
+            "event_gateway_available": self.event_gateway_available,
+            "activemq_available": self.activemq_available,
+            "active_system": self.event_system,
+            "stomp_installed": STOMP_AVAILABLE,
+            "handlers_registered": sum(len(handlers) for handlers in self.event_handlers.values())
+        }
+    
+    def register_event_handler(self, event_type: str, handler: Union[Callable[[EventNotification], None], Callable[[EventNotification], Any]]):
+        """Register an event handler for a specific event type"""
+        if event_type not in self.event_handlers:
+            self.event_handlers[event_type] = []
+        self.event_handlers[event_type].append(handler)
+    
+    def setup_content_handlers(self):
+        """Setup default content monitoring handlers"""
+        
+        async def handle_node_created(notification: EventNotification):
+            logger.info(f"Node created: {notification.node_id}")
+            
+        async def handle_node_updated(notification: EventNotification):
+            logger.info(f"Node updated: {notification.node_id}")
+            
+        async def handle_node_deleted(notification: EventNotification):
+            logger.info(f"Node deleted: {notification.node_id}")
+        
+        self.register_event_handler("node.created", handle_node_created)
+        self.register_event_handler("node.updated", handle_node_updated)
+        self.register_event_handler("node.deleted", handle_node_deleted)
+    
+    async def setup_content_monitoring(self) -> Dict[str, Any]:
+        """Setup content monitoring subscription"""
+        subscription = EventSubscription(
+            name="Content Monitoring",
+            events=["node.created", "node.updated", "node.deleted"]
+        )
+        
+        return await self.create_subscription(subscription)
+    
+    async def create_subscription(self, subscription: EventSubscription) -> Dict[str, Any]:
+        """Create event subscription based on available system"""
+        if self.event_system == "enterprise":
+            return await self._create_subscription_enterprise(subscription)
+        elif self.event_system == "community":
+            return await self._create_subscription_community(subscription)
+        else:
+            return {
+                "success": False,
+                "error": "No event system available"
+            }
+    
+    async def _create_subscription_enterprise(self, subscription: EventSubscription) -> Dict[str, Any]:
+        """Create Enterprise Event Gateway subscription"""
+        try:
+            url = f"http://{self.alfresco_host}:{self.enterprise_port}/alfresco/api/-default-/private/alfresco/versions/1/event-subscriptions"
+            
+            payload = {
+                "name": subscription.name,
+                "events": subscription.events,
+                "config": {
+                    "delivery": {
+                        "url": subscription.webhook_url or f"http://localhost:8080/webhook/{subscription.name}"
+                    }
+                }
+            }
+            
+            if not HTTPX_AVAILABLE:
+                return {
+                    "success": False,
+                    "error": "httpx not available for Enterprise Edition"
+                }
+            
+            # Mock successful creation for now
+            return {
+                "success": True,
+                "subscription_id": f"enterprise-{subscription.name}",
+                "system": "event-gateway",
+                "events": subscription.events
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    async def _create_subscription_community(self, subscription: EventSubscription) -> Dict[str, Any]:
+        """Create Community ActiveMQ subscription"""
+        try:
+            if not STOMP_AVAILABLE:
+                return {
+                    "success": False,
+                    "error": "stomp.py not installed for Community Edition"
+                }
+            
+            # Mock successful creation for now
+            return {
+                "success": True,
+                "subscription_id": f"community-{subscription.name}",
+                "system": "activemq",
+                "events": subscription.events
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    async def start_listening(self):
+        """Start listening for events based on active system"""
+        if self.event_system == "enterprise":
+            await self._start_listening_enterprise()
+        elif self.event_system == "community":
+            await self._start_listening_community()
+        else:
+            if self.debug:
+                logger.warning("No event system available for listening")
+    
+    async def _start_listening_enterprise(self):
+        """Start Enterprise Event Gateway listening"""
+        # In real implementation, this would setup webhook server
+        # or poll for events via REST API
+        if self.debug:
+            logger.info("Started listening for Enterprise Event Gateway events")
+    
+    async def _start_listening_community(self):
+        """Start Community ActiveMQ listening"""
+        if not STOMP_AVAILABLE:
+            if self.debug:
+                logger.warning("Cannot start Community listening: stomp.py not available")
+            return
+            
+        # In real implementation, this would setup STOMP listeners
+        if self.debug:
+            logger.info("Started listening for Community ActiveMQ events")
+    
+    def __repr__(self) -> str:
+        return f"AlfrescoEventClient(host={self.alfresco_host}, system={self.event_system})" 

python_alfresco_api/events/models.py

@@ -0,0 +1,35 @@
+"""
+Event System Models
+
+Data models for Alfresco event subscriptions and notifications.
+"""
+
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel
+
+
+class EventSubscription(BaseModel):
+    """Event subscription configuration"""
+    
+    name: str
+    events: List[str]
+    description: Optional[str] = None
+    webhook_url: Optional[str] = None  # For Enterprise Edition
+    filter_expression: Optional[str] = None
+    
+    class Config:
+        extra = "allow"
+
+
+class EventNotification(BaseModel):
+    """Standardized event notification format"""
+    
+    event_type: str
+    node_id: Optional[str] = None
+    user_id: Optional[str] = None
+    timestamp: Optional[str] = None
+    data: Optional[Dict[str, Any]] = None
+    source_system: Optional[str] = None  # 'community' or 'enterprise'
+    
+    class Config:
+        extra = "allow" 

python_alfresco_api/examples/basic_usage.py

@@ -0,0 +1,52 @@
+"""
+Basic Usage Example - python-alfresco-api
+
+Demonstrates the hybrid architecture with individual clients and factory pattern.
+"""
+
+import asyncio
+from python_alfresco_api import ClientFactory
+from python_alfresco_api.models import TicketBody
+
+async def main():
+    print("Python Alfresco API - Basic Usage Example")
+    print("=" * 50)
+    
+    # Method 1: Factory pattern (recommended)
+    print("\n1. Using Factory Pattern")
+    factory = ClientFactory(
+        base_url="https://alfresco.example.com",
+        username="admin", 
+        password="admin123"
+    )
+    
+    # Create individual clients
+    auth_client = factory.create_auth_client()
+    core_client = factory.create_core_client()
+    discovery_client = factory.create_discovery_client()
+    
+    print(f"   ✅ Created auth client: {auth_client.get_client_info()}")
+    print(f"   ✅ Created core client: {core_client.get_client_info()}")
+    print(f"   ✅ Created discovery client: {discovery_client.get_client_info()}")
+    
+    # Method 2: Individual clients
+    print("\n2. Using Individual Clients")
+    from python_alfresco_api import AlfrescoAuthClient, AlfrescoCoreClient
+    
+    auth_only = AlfrescoAuthClient("https://alfresco.example.com")
+    core_only = AlfrescoCoreClient("https://alfresco.example.com")
+    
+    print(f"   Standalone auth client: {auth_only.is_available()}")
+    print(f"   Standalone core client: {core_only.is_available()}")
+    
+    # Method 3: All clients at once
+    print("\n3. Creating All Clients")
+    all_clients = factory.create_all_clients()
+    
+    for api_name, client in all_clients.items():
+        print(f"   {api_name.upper()} client: {client.is_available()}")
+    
+    print("\nAll examples completed successfully!")
+
+if __name__ == "__main__":
+    asyncio.run(main())

python_alfresco_api/examples/llm_integration.py

@@ -0,0 +1,155 @@
+"""
+LLM Integration Example - python-alfresco-api
+
+Demonstrates using Pydantic models for LLM tool interfaces and MCP servers.
+"""
+
+from typing import Dict, Any, List
+from python_alfresco_api import ClientFactory
+from python_alfresco_api.models import TicketBody, NodeBody, SearchRequest
+
+# Initialize client factory
+factory = ClientFactory(
+    base_url="https://alfresco.example.com",
+    username="admin",
+    password="admin123"
+)
+
+# LLM Tool Functions using Pydantic models
+def authenticate_user_tool(credentials: TicketBody) -> Dict[str, Any]:
+    """
+    LLM tool for user authentication.
+    
+    Args:
+        credentials: User credentials with userId and password
+        
+    Returns:
+        Authentication result with ticket information
+    """
+    auth_client = factory.create_auth_client()
+    
+    try:
+        # The Pydantic model ensures type safety and validation
+        result = auth_client.create_ticket(credentials)
+        return {
+            "success": True,
+            "ticket": result.entry.id if result and result.entry else None,
+            "user": credentials.userId
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+def create_document_tool(document_data: NodeBody) -> Dict[str, Any]:
+    """
+    LLM tool for creating documents.
+    
+    Args:
+        document_data: Document information (name, nodeType, etc.)
+        
+    Returns:
+        Created document information
+    """
+    core_client = factory.create_core_client()
+    
+    try:
+        # Pydantic model provides perfect validation for LLM inputs
+        result = core_client.create_node(document_data)
+        return {
+            "success": True,
+            "node_id": result.entry.id if result and result.entry else None,
+            "name": document_data.name
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+def search_documents_tool(search_query: SearchRequest) -> Dict[str, Any]:
+    """
+    LLM tool for document search.
+    
+    Args:
+        search_query: Search parameters and query
+        
+    Returns:
+        Search results with documents
+    """
+    search_client = factory.create_search_client()
+    
+    try:
+        # Pydantic model handles complex search parameters
+        result = search_client.search(search_query)
+        return {
+            "success": True,
+            "total_items": result.list.pagination.totalItems if result and result.list and result.list.pagination else 0,
+            "documents": [entry.entry for entry in result.list.entries] if result and result.list and result.list.entries else []
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+# MCP Server Integration Example
+class AlfrescoMCPServer:
+    """
+    Model Context Protocol server for Alfresco integration.
+    
+    Provides natural language interface to Alfresco operations.
+    """
+    
+    def __init__(self, base_url: str, username: str, password: str):
+        self.factory = ClientFactory(base_url, username, password)
+    
+    async def handle_natural_language_query(self, query: str) -> Dict[str, Any]:
+        """
+        Handle natural language queries like:
+        - "Find all documents modified this week"
+        - "Create a new folder called 'Projects'"
+        - "Search for documents containing 'budget'"
+        """
+        
+        # This would integrate with your LLM to parse the natural language
+        # and convert to appropriate API calls using the Pydantic models
+        
+        if "search" in query.lower():
+            # Convert natural language to SearchRequest
+            search_request = SearchRequest(
+                query={"query": query},
+                paging={"maxItems": 25}
+            )
+            return search_documents_tool(search_request)
+        
+        elif "create" in query.lower() and "folder" in query.lower():
+            # Convert natural language to NodeBody for folder creation
+            folder_data = NodeBody(
+                name="Projects",  # Extract from query
+                nodeType="cm:folder"
+            )
+            return create_document_tool(folder_data)
+        
+        else:
+            return {"success": False, "error": "Query not understood"}
+
+# Example usage
+if __name__ == "__main__":
+    print("LLM Integration Example")
+    print("=" * 30)
+    
+    # Test authentication tool
+    creds = TicketBody(userId="admin", password="admin123")
+    auth_result = authenticate_user_tool(creds)
+    print(f"Authentication: {auth_result}")
+    
+    # Test document creation tool  
+    doc_data = NodeBody(name="test-document.txt", nodeType="cm:content")
+    create_result = create_document_tool(doc_data)
+    print(f"Document creation: {create_result}")
+    
+    print("\nPerfect for LLM tool interfaces!")
+    print("Type-safe with Pydantic validation!")
+    print("Ready for MCP server integration!")