python-alfresco-api 1.1.2__py3-none-any.whl → 1.1.4__py3-none-any.whl

python_alfresco_api/clients/__init__.py

@@ -9,11 +9,11 @@ This module provides a three-tier architecture:
 - Level 3: Operation-specific models for ONE operation
 
 Key Benefits:
-- 🚀 Better performance with lazy loading
-- 📦 Organized locality (models exactly where used)
-- 🔧 Structured imports and clear organization
-- 📋 Pydantic v2 models for better type checking in general and for AI/LLM integration
-- ⚡ Dual sync/async APIs (sync for simpler use, async for web apps)
+- [PERFORMANCE] Better performance with lazy loading
+- [ORGANIZATION] Organized locality (models exactly where used)
+- [STRUCTURE] Structured imports and clear organization
+- [MODELS] Pydantic v2 models for better type checking in general and for AI/LLM integration
+- [ASYNC] Dual sync/async APIs (sync for simpler use, async for web apps)
 """
 
 # Modern clients with three-tier architecture and lazy loading

python_alfresco_api/clients/auth/auth_client.py

@@ -137,7 +137,7 @@ class AlfrescoAuthClient:
         if self._authentication is None:
             # Lazy load the authentication client
             from .authentication import AuthenticationClient
-            self._authentication = AuthenticationClient(self._client_factory)
+            self._authentication = AuthenticationClient(self)
         return self._authentication
     
     # =================================================================

python_alfresco_api/clients/auth/authentication/authentication_client.py

@@ -22,9 +22,9 @@ from ....raw_clients.alfresco_auth_client.auth_client.types import UNSET, Unset
 from httpx import Response
 
 # Import model types for proper parameter signatures
-from ....raw_clients.alfresco_auth_client.auth_client.models.ticketbody import TicketBody
-from ....raw_clients.alfresco_auth_client.auth_client.models.ticketentry import TicketEntry
-from ....raw_clients.alfresco_auth_client.auth_client.models.validticketentry import ValidTicketEntry
+from ....raw_clients.alfresco_auth_client.auth_client.models.ticket_body import TicketBody
+from ....raw_clients.alfresco_auth_client.auth_client.models.ticket_entry import TicketEntry
+from ....raw_clients.alfresco_auth_client.auth_client.models.valid_ticket_entry import ValidTicketEntry
 
 # Import from Level 3 (operation-specific models)
 from .models import AuthenticationResponse, AuthenticationListResponse, CreateAuthenticationRequest
@@ -53,9 +53,9 @@ class AuthenticationClient:
     - Detailed sync/async for full HTTP response access
     """
     
-    def __init__(self, client_factory):
+    def __init__(self, parent_client):
         """Initialize with client factory for raw client access."""
-        self._client_factory = client_factory
+        self.parent_client = parent_client
         self._raw_client = None
         
         # Store raw operation references
@@ -64,31 +64,213 @@ class AuthenticationClient:
             self._delete_ticket = _delete_ticket
             self._validate_ticket = _validate_ticket
     
-    def _get_raw_client(self):
-        """Get or create the raw client."""
-        if self._raw_client is None:
-            # Import the raw auth client directly
-            from ....raw_clients.alfresco_auth_client.auth_client.client import AuthenticatedClient
-            
-            # Create the raw client with same auth setup
-            self._raw_client = AuthenticatedClient(
-                base_url=f"{self._client_factory.base_url}/alfresco/api/-default-/public/authentication/versions/1",
-                token=self._client_factory.auth.get_auth_token(),
-                prefix=self._client_factory.auth.get_auth_prefix(),
-                verify_ssl=self._client_factory.verify_ssl
-            )
-        return self._raw_client
+    @property
+    def raw_client(self):
+        """Delegate to parent client's raw client."""
+        return self.parent_client.raw_client
     
-    def get_httpx_client(self):
+    @property
+    def httpx_client(self):
+        """Delegate to parent client's httpx client."""
+        return self.parent_client.httpx_client
+    
+    # =================================================================
+    # AUTHENTICATION OPERATIONS - 4-PATTERN IMPLEMENTATION
+    # =================================================================
+    
+    def create_ticket(
+        self,
+        username: str,
+        password: str
+    ) -> Optional[Any]:
+        """
+        Create authentication ticket (sync).
+        
+        Creates a new authentication ticket for the given credentials.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        from ....raw_clients.alfresco_auth_client.auth_client.models.ticket_body import TicketBody
+        
+        ticket_body = TicketBody(user_id=username, password=password)
+        
+        return self._create_ticket.sync(
+            client=self.raw_client,
+            body=ticket_body
+        )
+    
+    async def create_ticket_async(
+        self,
+        username: str,
+        password: str
+    ) -> Optional[Any]:
+        """
+        Create authentication ticket (async).
+        
+        Creates a new authentication ticket for the given credentials.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        from ....raw_clients.alfresco_auth_client.auth_client.models.ticket_body import TicketBody
+        
+        ticket_body = TicketBody(user_id=username, password=password)
+        
+        return await self._create_ticket.asyncio(
+            client=self.raw_client,
+            body=ticket_body
+        )
+    
+    def create_ticket_detailed(
+        self,
+        username: str,
+        password: str
+    ) -> Response:
+        """
+        Create authentication ticket (detailed sync).
+        
+        Creates a new authentication ticket with full HTTP response.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        from ....raw_clients.alfresco_auth_client.auth_client.models.ticket_body import TicketBody
+        
+        ticket_body = TicketBody(user_id=username, password=password)
+        
+        return self._create_ticket.sync_detailed(
+            client=self.raw_client,
+            body=ticket_body
+        )
+    
+    async def create_ticket_detailed_async(
+        self,
+        username: str,
+        password: str
+    ) -> Response:
+        """
+        Create authentication ticket (detailed async).
+        
+        Creates a new authentication ticket with full HTTP response.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        from ....raw_clients.alfresco_auth_client.auth_client.models.ticket_body import TicketBody
+        
+        ticket_body = TicketBody(user_id=username, password=password)
+        
+        return await self._create_ticket.asyncio_detailed(
+            client=self.raw_client,
+            body=ticket_body
+        )
+    
+    def validate_ticket(self) -> Optional[Any]:
+        """
+        Validate current authentication ticket (sync).
+        
+        Validates the current authentication ticket.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        return self._validate_ticket.sync(
+            client=self.raw_client
+        )
+    
+    async def validate_ticket_async(self) -> Optional[Any]:
+        """
+        Validate current authentication ticket (async).
+        
+        Validates the current authentication ticket.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        return await self._validate_ticket.asyncio(
+            client=self.raw_client
+        )
+    
+    def validate_ticket_detailed(self) -> Response:
+        """
+        Validate current authentication ticket (detailed sync).
+        
+        Validates the current authentication ticket with full HTTP response.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        return self._validate_ticket.sync_detailed(
+            client=self.raw_client
+        )
+    
+    async def validate_ticket_detailed_async(self) -> Response:
+        """
+        Validate current authentication ticket (detailed async).
+        
+        Validates the current authentication ticket with full HTTP response.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        return await self._validate_ticket.asyncio_detailed(
+            client=self.raw_client
+        )
+    
+    def delete_ticket(self) -> Optional[Any]:
         """
-        Get direct access to raw httpx client for advanced operations.
+        Delete current authentication ticket (sync).
         
-        Perfect for MCP servers that need raw HTTP access.
+        Deletes/invalidates the current authentication ticket.
         """
-        return self._get_raw_client().get_httpx_client()
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        return self._delete_ticket.sync(
+            client=self.raw_client
+        )
+    
+    async def delete_ticket_async(self) -> Optional[Any]:
+        """
+        Delete current authentication ticket (async).
+        
+        Deletes/invalidates the current authentication ticket.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        return await self._delete_ticket.asyncio(
+            client=self.raw_client
+        )
+    
+    def delete_ticket_detailed(self) -> Response:
+        """
+        Delete current authentication ticket (detailed sync).
+        
+        Deletes/invalidates the current authentication ticket with full HTTP response.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        return self._delete_ticket.sync_detailed(
+            client=self.raw_client
+        )
+    
+    async def delete_ticket_detailed_async(self) -> Response:
+        """
+        Delete current authentication ticket (detailed async).
+        
+        Deletes/invalidates the current authentication ticket with full HTTP response.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        return await self._delete_ticket.asyncio_detailed(
+            client=self.raw_client
+        )
     
-    # Placeholder for authentication operations - will be populated from the original file
     def __repr__(self) -> str:
         """String representation for debugging."""
-        base_url = getattr(self._client_factory, 'base_url', 'unknown')
+        base_url = getattr(self.parent_client._client_factory, 'base_url', 'unknown')
         return f"AlfrescoAuthenticationClient(base_url='{base_url}')" 

python_alfresco_api/clients/conversion_utils.py

@@ -184,7 +184,7 @@ def enhanced_search_example():
 
 if __name__ == "__main__":
     """Test the conversion utilities."""
-    print("🔧 Testing Conversion Utilities")
+    print("[TESTING] Testing Conversion Utilities")
     
     # Test 1: Enhanced create node
     print("\n1. Enhanced create node conversion:")
@@ -194,4 +194,4 @@ if __name__ == "__main__":
     print("\n2. Enhanced search example:")
     enhanced_search_example()
     
-    print("\n✅ Conversion utilities proof-of-concept complete!") 
+    print("\n[SUCCESS] Conversion utilities proof-of-concept complete!") 

python_alfresco_api/clients/core/actions/actions_client.py

@@ -45,9 +45,9 @@ class ActionsClient:
     - Detailed sync/async for full HTTP response access
     """
     
-    def __init__(self, client_factory):
+    def __init__(self, parent_client):
         """Initialize with client factory for raw client access."""
-        self._client_factory = client_factory
+        self.parent_client = parent_client
         self._raw_client = None
         
         # Store raw operation references
@@ -57,28 +57,15 @@ class ActionsClient:
             self._list_actions = _list_actions
             self._node_actions = _node_actions
     
-    def _get_raw_client(self):
-        """Get or create the raw client."""
-        if self._raw_client is None:
-            # Import the raw core client directly
-            from ....raw_clients.alfresco_core_client.core_client.client import AuthenticatedClient
-            
-            # Create the raw client with same auth setup
-            self._raw_client = AuthenticatedClient(
-                base_url=f"{self._client_factory.base_url}/alfresco/api/-default-/public/alfresco/versions/1",
-                token=self._client_factory.auth.get_auth_token(),
-                prefix=self._client_factory.auth.get_auth_prefix(),
-                verify_ssl=self._client_factory.verify_ssl
-            )
-        return self._raw_client
+    @property
+    def raw_client(self):
+        """Delegate to parent client's raw client."""
+        return self.parent_client.raw_client
     
-    def get_httpx_client(self):
-        """
-        Get direct access to raw httpx client for advanced operations.
-        
-        Perfect for MCP servers that need raw HTTP access.
-        """
-        return self._get_raw_client().get_httpx_client()
+    @property
+    def httpx_client(self):
+        """Delegate to parent client's httpx client."""
+        return self.parent_client.httpx_client
     
     # ==================== 4-PATTERN OPERATIONS ====================
 
@@ -94,7 +81,7 @@ class ActionsClient:
         if not hasattr(self, '_action_details'):
             raise ImportError("Raw client operation not available")
         
-        result = self._action_details.sync(client=self._get_raw_client(), action_definition_id=action_definition_id)
+        result = self._action_details.sync(client=self.raw_client, action_definition_id=action_definition_id)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -110,7 +97,7 @@ class ActionsClient:
         if not hasattr(self, '_action_details'):
             raise ImportError("Raw client operation not available")
         
-        result = await self._action_details.asyncio(client=self._get_raw_client(), action_definition_id=action_definition_id)
+        result = await self._action_details.asyncio(client=self.raw_client, action_definition_id=action_definition_id)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -126,7 +113,7 @@ class ActionsClient:
         if not hasattr(self, '_action_details'):
             raise ImportError("Raw client operation not available")
         
-        return self._action_details.sync_detailed(client=self._get_raw_client(), action_definition_id=action_definition_id)
+        return self._action_details.sync_detailed(client=self.raw_client, action_definition_id=action_definition_id)
     
     async def action_details_detailed_async(self, action_definition_id: Any):
         """
@@ -138,7 +125,7 @@ class ActionsClient:
         if not hasattr(self, '_action_details'):
             raise ImportError("Raw client operation not available")
         
-        return await self._action_details.asyncio_detailed(client=self._get_raw_client(), action_definition_id=action_definition_id)
+        return await self._action_details.asyncio_detailed(client=self.raw_client, action_definition_id=action_definition_id)
 
     # ==================== ACTION_EXEC OPERATION ====================
     
@@ -152,7 +139,7 @@ class ActionsClient:
         if not hasattr(self, '_action_exec'):
             raise ImportError("Raw client operation not available")
         
-        result = self._action_exec.sync(client=self._get_raw_client(), body=body)
+        result = self._action_exec.sync(client=self.raw_client, body=body)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -168,7 +155,7 @@ class ActionsClient:
         if not hasattr(self, '_action_exec'):
             raise ImportError("Raw client operation not available")
         
-        result = await self._action_exec.asyncio(client=self._get_raw_client(), body=body)
+        result = await self._action_exec.asyncio(client=self.raw_client, body=body)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -184,7 +171,7 @@ class ActionsClient:
         if not hasattr(self, '_action_exec'):
             raise ImportError("Raw client operation not available")
         
-        return self._action_exec.sync_detailed(client=self._get_raw_client(), body=body)
+        return self._action_exec.sync_detailed(client=self.raw_client, body=body)
     
     async def action_exec_detailed_async(self, body: Any):
         """
@@ -196,7 +183,7 @@ class ActionsClient:
         if not hasattr(self, '_action_exec'):
             raise ImportError("Raw client operation not available")
         
-        return await self._action_exec.asyncio_detailed(client=self._get_raw_client(), body=body)
+        return await self._action_exec.asyncio_detailed(client=self.raw_client, body=body)
 
     # ==================== LIST_ACTIONS OPERATION ====================
     
@@ -210,7 +197,7 @@ class ActionsClient:
         if not hasattr(self, '_list_actions'):
             raise ImportError("Raw client operation not available")
         
-        result = self._list_actions.sync(client=self._get_raw_client(), skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
+        result = self._list_actions.sync(client=self.raw_client, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -226,7 +213,7 @@ class ActionsClient:
         if not hasattr(self, '_list_actions'):
             raise ImportError("Raw client operation not available")
         
-        result = await self._list_actions.asyncio(client=self._get_raw_client(), skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
+        result = await self._list_actions.asyncio(client=self.raw_client, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -242,7 +229,7 @@ class ActionsClient:
         if not hasattr(self, '_list_actions'):
             raise ImportError("Raw client operation not available")
         
-        return self._list_actions.sync_detailed(client=self._get_raw_client(), skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
+        return self._list_actions.sync_detailed(client=self.raw_client, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
     
     async def list_actions_detailed_async(self, skip_count: Any, max_items: Any, order_by: Any, fields: Any):
         """
@@ -254,7 +241,7 @@ class ActionsClient:
         if not hasattr(self, '_list_actions'):
             raise ImportError("Raw client operation not available")
         
-        return await self._list_actions.asyncio_detailed(client=self._get_raw_client(), skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
+        return await self._list_actions.asyncio_detailed(client=self.raw_client, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
 
     # ==================== NODE_ACTIONS OPERATION ====================
     
@@ -268,7 +255,7 @@ class ActionsClient:
         if not hasattr(self, '_node_actions'):
             raise ImportError("Raw client operation not available")
         
-        result = self._node_actions.sync(client=self._get_raw_client(), node_id=node_id, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
+        result = self._node_actions.sync(client=self.raw_client, node_id=node_id, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -284,7 +271,7 @@ class ActionsClient:
         if not hasattr(self, '_node_actions'):
             raise ImportError("Raw client operation not available")
         
-        result = await self._node_actions.asyncio(client=self._get_raw_client(), node_id=node_id, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
+        result = await self._node_actions.asyncio(client=self.raw_client, node_id=node_id, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -300,7 +287,7 @@ class ActionsClient:
         if not hasattr(self, '_node_actions'):
             raise ImportError("Raw client operation not available")
         
-        return self._node_actions.sync_detailed(client=self._get_raw_client(), node_id=node_id, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
+        return self._node_actions.sync_detailed(client=self.raw_client, node_id=node_id, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
     
     async def node_actions_detailed_async(self, node_id: Any, skip_count: Any, max_items: Any, order_by: Any, fields: Any):
         """
@@ -312,7 +299,7 @@ class ActionsClient:
         if not hasattr(self, '_node_actions'):
             raise ImportError("Raw client operation not available")
         
-        return await self._node_actions.asyncio_detailed(client=self._get_raw_client(), node_id=node_id, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
+        return await self._node_actions.asyncio_detailed(client=self.raw_client, node_id=node_id, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
     
     def __repr__(self) -> str:
         """String representation for debugging."""

python_alfresco_api/clients/core/activities/activities_client.py

@@ -42,37 +42,24 @@ class ActivitiesClient:
     - Detailed sync/async for full HTTP response access
     """
     
-    def __init__(self, client_factory):
+    def __init__(self, parent_client):
         """Initialize with client factory for raw client access."""
-        self._client_factory = client_factory
+        self.parent_client = parent_client
         self._raw_client = None
         
         # Store raw operation references
         if RAW_OPERATIONS_AVAILABLE:
             self._list_activities_for_person = _list_activities_for_person
     
-    def _get_raw_client(self):
-        """Get or create the raw client."""
-        if self._raw_client is None:
-            # Import the raw core client directly
-            from ....raw_clients.alfresco_core_client.core_client.client import AuthenticatedClient
-            
-            # Create the raw client with same auth setup
-            self._raw_client = AuthenticatedClient(
-                base_url=f"{self._client_factory.base_url}/alfresco/api/-default-/public/alfresco/versions/1",
-                token=self._client_factory.auth.get_auth_token(),
-                prefix=self._client_factory.auth.get_auth_prefix(),
-                verify_ssl=self._client_factory.verify_ssl
-            )
-        return self._raw_client
+    @property
+    def raw_client(self):
+        """Delegate to parent client's raw client."""
+        return self.parent_client.raw_client
     
-    def get_httpx_client(self):
-        """
-        Get direct access to raw httpx client for advanced operations.
-        
-        Perfect for MCP servers that need raw HTTP access.
-        """
-        return self._get_raw_client().get_httpx_client()
+    @property
+    def httpx_client(self):
+        """Delegate to parent client's httpx client."""
+        return self.parent_client.httpx_client
     
     # ==================== 4-PATTERN OPERATIONS ====================
 
@@ -88,7 +75,7 @@ class ActivitiesClient:
         if not hasattr(self, '_list_activities_for_person'):
             raise ImportError("Raw client operation not available")
         
-        result = self._list_activities_for_person.sync(client=self._get_raw_client(), person_id=person_id, skip_count=skip_count, max_items=max_items, who=who, site_id=site_id, fields=fields)
+        result = self._list_activities_for_person.sync(client=self.raw_client, person_id=person_id, skip_count=skip_count, max_items=max_items, who=who, site_id=site_id, fields=fields)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -104,7 +91,7 @@ class ActivitiesClient:
         if not hasattr(self, '_list_activities_for_person'):
             raise ImportError("Raw client operation not available")
         
-        result = await self._list_activities_for_person.asyncio(client=self._get_raw_client(), person_id=person_id, skip_count=skip_count, max_items=max_items, who=who, site_id=site_id, fields=fields)
+        result = await self._list_activities_for_person.asyncio(client=self.raw_client, person_id=person_id, skip_count=skip_count, max_items=max_items, who=who, site_id=site_id, fields=fields)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -120,7 +107,7 @@ class ActivitiesClient:
         if not hasattr(self, '_list_activities_for_person'):
             raise ImportError("Raw client operation not available")
         
-        return self._list_activities_for_person.sync_detailed(client=self._get_raw_client(), person_id=person_id, skip_count=skip_count, max_items=max_items, who=who, site_id=site_id, fields=fields)
+        return self._list_activities_for_person.sync_detailed(client=self.raw_client, person_id=person_id, skip_count=skip_count, max_items=max_items, who=who, site_id=site_id, fields=fields)
     
     async def list_activities_for_person_detailed_async(self, person_id: Any, skip_count: Any, max_items: Any, who: Any, site_id: Any, fields: Any):
         """
@@ -132,7 +119,7 @@ class ActivitiesClient:
         if not hasattr(self, '_list_activities_for_person'):
             raise ImportError("Raw client operation not available")
         
-        return await self._list_activities_for_person.asyncio_detailed(client=self._get_raw_client(), person_id=person_id, skip_count=skip_count, max_items=max_items, who=who, site_id=site_id, fields=fields)
+        return await self._list_activities_for_person.asyncio_detailed(client=self.raw_client, person_id=person_id, skip_count=skip_count, max_items=max_items, who=who, site_id=site_id, fields=fields)
 
     
     def __repr__(self) -> str: