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

python_alfresco_api/__init__.py

@@ -0,0 +1,43 @@
+"""
+Python Alfresco API - Hybrid Architecture
+
+The perfect combination of:
+- Pydantic v2 models for LLM integration & MCP servers
+- Professional HTTP clients with async support
+- Individual clients for enterprise modularity
+- Factory pattern for easy configuration
+
+Generated using the proven hybrid approach:
+datamodel-code-generator + openapi-python-client
+"""
+
+from .client_factory import ClientFactory
+from .auth_util import AuthUtil
+
+# Individual clients
+from .clients.auth_client import AlfrescoAuthClient
+from .clients.core_client import AlfrescoCoreClient  
+from .clients.discovery_client import AlfrescoDiscoveryClient
+from .clients.search_client import AlfrescoSearchClient
+from .clients.workflow_client import AlfrescoWorkflowClient
+from .clients.model_client import AlfrescoModelClient
+from .clients.search_sql_client import AlfrescoSearchSqlClient
+
+# Pydantic models for LLM integration
+from .models import *
+
+__version__ = "1.0.0"
+__all__ = [
+    # Factory & utilities
+    "ClientFactory",
+    "AuthUtil",
+    
+    # Individual clients
+    "AlfrescoAuthClient",
+    "AlfrescoCoreClient", 
+    "AlfrescoDiscoveryClient",
+    "AlfrescoSearchClient",
+    "AlfrescoWorkflowClient", 
+    "AlfrescoModelClient",
+    "AlfrescoSearchSqlClient"
+]

python_alfresco_api/auth_util.py

@@ -0,0 +1,103 @@
+"""
+Shared Authentication Utility
+
+Provides authentication management that can be shared across multiple API clients.
+Handles ticket-based authentication with automatic renewal.
+"""
+
+import asyncio
+from typing import Optional, Dict, Any
+from datetime import datetime, timedelta
+
+class AuthUtil:
+    """
+    Shared authentication utility for Alfresco APIs.
+    
+    Handles ticket-based authentication with automatic renewal.
+    Can be shared across multiple API clients.
+    """
+    
+    def __init__(
+        self,
+        base_url: str,
+        username: str,
+        password: str,
+        verify_ssl: bool = True,
+        timeout: int = 30
+    ):
+        """
+        Initialize authentication utility.
+        
+        Args:
+            base_url: Base URL of Alfresco instance
+            username: Alfresco username
+            password: Alfresco password
+            verify_ssl: Whether to verify SSL certificates
+            timeout: Request timeout in seconds
+        """
+        self.base_url = base_url.rstrip('/')
+        self.username = username
+        self.password = password
+        self.verify_ssl = verify_ssl
+        self.timeout = timeout
+        
+        self.ticket = None
+        self.ticket_expires = None
+        self._authenticated = False
+    
+    async def authenticate(self) -> bool:
+        """
+        Authenticate with Alfresco and get ticket.
+        
+        Returns:
+            True if authentication successful, False otherwise
+        """
+        try:
+            # Import here to avoid circular imports
+            from .clients.auth_client import AlfrescoAuthClient
+            from .models.alfresco_auth_models import TicketBody
+            
+            auth_client = AlfrescoAuthClient(self.base_url, None, self.verify_ssl, self.timeout)
+            
+            ticket_body = TicketBody(userId=self.username, password=self.password)
+            ticket_response = await auth_client.create_ticket(ticket_body)
+            
+            if ticket_response and hasattr(ticket_response, 'entry'):
+                self.ticket = ticket_response.entry.id
+                # Tickets typically expire after 1 hour
+                self.ticket_expires = datetime.now() + timedelta(hours=1)
+                self._authenticated = True
+                return True
+                
+        except Exception as e:
+            print(f"Authentication failed: {e}")
+            self._authenticated = False
+        
+        return False
+    
+    def is_authenticated(self) -> bool:
+        """Check if currently authenticated with valid ticket"""
+        if not self._authenticated or not self.ticket:
+            return False
+        
+        if self.ticket_expires and datetime.now() >= self.ticket_expires:
+            self._authenticated = False
+            return False
+        
+        return True
+    
+    def get_auth_headers(self) -> Dict[str, str]:
+        """Get authentication headers for API requests"""
+        if not self.is_authenticated():
+            return {}
+        
+        return {
+            "X-Alfresco-Ticket": self.ticket
+        }
+    
+    async def ensure_authenticated(self) -> bool:
+        """Ensure we have valid authentication, refresh if needed"""
+        if self.is_authenticated():
+            return True
+        
+        return await self.authenticate()

python_alfresco_api/client_factory.py

@@ -0,0 +1,111 @@
+"""
+Client Factory for Alfresco APIs
+
+Provides easy instantiation of individual clients with shared configuration.
+Perfect for enterprise applications and microservices.
+"""
+
+from typing import Optional, Dict, Any
+from .auth_util import AuthUtil
+from .clients.auth_client import AlfrescoAuthClient
+from .clients.core_client import AlfrescoCoreClient
+from .clients.discovery_client import AlfrescoDiscoveryClient
+from .clients.search_client import AlfrescoSearchClient
+from .clients.workflow_client import AlfrescoWorkflowClient
+from .clients.model_client import AlfrescoModelClient
+from .clients.search_sql_client import AlfrescoSearchSqlClient
+
+class MasterClient:
+    """
+    Master client with dot syntax access to all APIs.
+    Provides unified interface: master_client.core.something()
+    """
+    
+    def __init__(self, clients_dict: Dict[str, Any]):
+        """Initialize master client with all API clients."""
+        self.auth = clients_dict['auth']
+        self.core = clients_dict['core'] 
+        self.discovery = clients_dict['discovery']
+        self.search = clients_dict['search']
+        self.workflow = clients_dict['workflow']
+        self.model = clients_dict['model']
+        self.search_sql = clients_dict['search_sql']
+
+class ClientFactory:
+    """
+    Factory for creating Alfresco API clients.
+    
+    Supports both individual client creation and shared authentication.
+    """
+    
+    def __init__(
+        self,
+        base_url: str,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        verify_ssl: bool = True,
+        timeout: int = 30
+    ):
+        """
+        Initialize the client factory.
+        
+        Args:
+            base_url: Base URL of Alfresco instance
+            username: Optional username for authentication
+            password: Optional password for authentication  
+            verify_ssl: Whether to verify SSL certificates
+            timeout: Request timeout in seconds
+        """
+        self.base_url = base_url
+        self.verify_ssl = verify_ssl
+        self.timeout = timeout
+        
+        # Initialize auth utility if credentials provided
+        self.auth = None
+        if username and password:
+            self.auth = AuthUtil(base_url, username, password, verify_ssl, timeout)
+    
+    def create_auth_client(self) -> AlfrescoAuthClient:
+        """Create Authentication API client"""
+        return AlfrescoAuthClient(self.base_url, self.auth, self.verify_ssl, self.timeout)
+    
+    def create_core_client(self) -> AlfrescoCoreClient:
+        """Create Core API client"""
+        return AlfrescoCoreClient(self.base_url, self.auth, self.verify_ssl, self.timeout)
+    
+    def create_discovery_client(self) -> AlfrescoDiscoveryClient:
+        """Create Discovery API client"""
+        return AlfrescoDiscoveryClient(self.base_url, self.auth, self.verify_ssl, self.timeout)
+    
+    def create_search_client(self) -> AlfrescoSearchClient:
+        """Create Search API client"""
+        return AlfrescoSearchClient(self.base_url, self.auth, self.verify_ssl, self.timeout)
+    
+    def create_workflow_client(self) -> AlfrescoWorkflowClient:
+        """Create Workflow API client"""
+        return AlfrescoWorkflowClient(self.base_url, self.auth, self.verify_ssl, self.timeout)
+    
+    def create_model_client(self) -> AlfrescoModelClient:
+        """Create Model API client"""
+        return AlfrescoModelClient(self.base_url, self.auth, self.verify_ssl, self.timeout)
+    
+    def create_search_sql_client(self) -> AlfrescoSearchSqlClient:
+        """Create Search SQL API client"""
+        return AlfrescoSearchSqlClient(self.base_url, self.auth, self.verify_ssl, self.timeout)
+    
+    def create_all_clients(self) -> Dict[str, Any]:
+        """Create all available clients"""
+        return {
+            "auth": self.create_auth_client(),
+            "core": self.create_core_client(),
+            "discovery": self.create_discovery_client(),
+            "search": self.create_search_client(),
+            "workflow": self.create_workflow_client(),
+            "model": self.create_model_client(),
+            "search_sql": self.create_search_sql_client()
+        }
+    
+    def create_master_client(self) -> MasterClient:
+        """Create master client with dot syntax access"""
+        clients = self.create_all_clients()
+        return MasterClient(clients)

python_alfresco_api/clients/__init__.py

@@ -0,0 +1 @@
+"""Individual Alfresco API clients"""

python_alfresco_api/clients/auth_client.py

@@ -0,0 +1,85 @@
+"""
+AlfrescoAuthClient - Individual client for Alfresco AUTH 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_auth_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 AlfrescoAuthClient:
+    """
+    Individual client for Alfresco AUTH 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 auth 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 auth: {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": "auth",
+            "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/core_client.py

@@ -0,0 +1,85 @@
+"""
+AlfrescoCoreClient - Individual client for Alfresco CORE 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_core_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 AlfrescoCoreClient:
+    """
+    Individual client for Alfresco CORE 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 core 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 core: {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": "core",
+            "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/discovery_client.py

@@ -0,0 +1,85 @@
+"""
+AlfrescoDiscoveryClient - Individual client for Alfresco DISCOVERY 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_discovery_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 AlfrescoDiscoveryClient:
+    """
+    Individual client for Alfresco DISCOVERY 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 discovery 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 discovery: {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": "discovery",
+            "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/model_client.py

@@ -0,0 +1,85 @@
+"""
+AlfrescoModelClient - Individual client for Alfresco MODEL 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_model_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 AlfrescoModelClient:
+    """
+    Individual client for Alfresco MODEL 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 model 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 model: {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": "model",
+            "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/search_client.py

@@ -0,0 +1,85 @@
+"""
+AlfrescoSearchClient - Individual client for Alfresco SEARCH 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_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 AlfrescoSearchClient:
+    """
+    Individual client for Alfresco SEARCH 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 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: {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",
+            "base_url": self.base_url,
+            "authenticated": self.auth_util.is_authenticated() if self.auth_util else False,
+            "client_available": self._client_available
+        }