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

python_alfresco_api/raw_clients/alfresco_workflow_client/workflow_client/models/variable_paging.py

@@ -0,0 +1,72 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.variable_paging_list import VariablePagingList
+
+
+T = TypeVar("T", bound="VariablePaging")
+
+
+@_attrs_define
+class VariablePaging:
+    """
+    Attributes:
+        list_ (Union[Unset, VariablePagingList]):
+    """
+
+    list_: Union[Unset, "VariablePagingList"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        list_: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.list_, Unset):
+            list_ = self.list_.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if list_ is not UNSET:
+            field_dict["list"] = list_
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.variable_paging_list import VariablePagingList
+
+        d = dict(src_dict)
+        _list_ = d.pop("list", UNSET)
+        list_: Union[Unset, VariablePagingList]
+        if isinstance(_list_, Unset):
+            list_ = UNSET
+        else:
+            list_ = VariablePagingList.from_dict(_list_)
+
+        variable_paging = cls(
+            list_=list_,
+        )
+
+        variable_paging.additional_properties = d
+        return variable_paging
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

python_alfresco_api/raw_clients/alfresco_workflow_client/workflow_client/models/variable_paging_list.py

@@ -0,0 +1,93 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.pagination import Pagination
+    from ..models.variable_entry import VariableEntry
+
+
+T = TypeVar("T", bound="VariablePagingList")
+
+
+@_attrs_define
+class VariablePagingList:
+    """
+    Attributes:
+        entries (Union[Unset, list['VariableEntry']]):
+        pagination (Union[Unset, Pagination]):
+    """
+
+    entries: Union[Unset, list["VariableEntry"]] = UNSET
+    pagination: Union[Unset, "Pagination"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        entries: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.entries, Unset):
+            entries = []
+            for entries_item_data in self.entries:
+                entries_item = entries_item_data.to_dict()
+                entries.append(entries_item)
+
+        pagination: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.pagination, Unset):
+            pagination = self.pagination.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if entries is not UNSET:
+            field_dict["entries"] = entries
+        if pagination is not UNSET:
+            field_dict["pagination"] = pagination
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.pagination import Pagination
+        from ..models.variable_entry import VariableEntry
+
+        d = dict(src_dict)
+        entries = []
+        _entries = d.pop("entries", UNSET)
+        for entries_item_data in _entries or []:
+            entries_item = VariableEntry.from_dict(entries_item_data)
+
+            entries.append(entries_item)
+
+        _pagination = d.pop("pagination", UNSET)
+        pagination: Union[Unset, Pagination]
+        if isinstance(_pagination, Unset):
+            pagination = UNSET
+        else:
+            pagination = Pagination.from_dict(_pagination)
+
+        variable_paging_list = cls(
+            entries=entries,
+            pagination=pagination,
+        )
+
+        variable_paging_list.additional_properties = d
+        return variable_paging_list
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

python_alfresco_api/raw_clients/alfresco_workflow_client/workflow_client/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

python_alfresco_api/raw_clients/alfresco_workflow_client/workflow_client/types.py

@@ -0,0 +1,54 @@
+"""Contains some shared types for properties"""
+
+from collections.abc import Mapping, MutableMapping
+from http import HTTPStatus
+from typing import IO, BinaryIO, Generic, Literal, Optional, TypeVar, Union
+
+from attrs import define
+
+
+class Unset:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET: Unset = Unset()
+
+# The types that `httpx.Client(files=)` can accept, copied from that library.
+FileContent = Union[IO[bytes], bytes, str]
+FileTypes = Union[
+    # (filename, file (or bytes), content_type)
+    tuple[Optional[str], FileContent, Optional[str]],
+    # (filename, file (or bytes), content_type, headers)
+    tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]],
+]
+RequestFiles = list[tuple[str, FileTypes]]
+
+
+@define
+class File:
+    """Contains information for file uploads"""
+
+    payload: BinaryIO
+    file_name: Optional[str] = None
+    mime_type: Optional[str] = None
+
+    def to_tuple(self) -> FileTypes:
+        """Return a tuple representation that httpx will accept for multipart/form-data"""
+        return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+    """A response from an endpoint"""
+
+    status_code: HTTPStatus
+    content: bytes
+    headers: MutableMapping[str, str]
+    parsed: Optional[T]
+
+
+__all__ = ["UNSET", "File", "FileTypes", "RequestFiles", "Response", "Unset"]

python_alfresco_api/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for python-alfresco-api"""

python_alfresco_api/tests/test_basic.py

@@ -0,0 +1,115 @@
+"""
+Basic tests for python-alfresco-api hybrid architecture
+"""
+
+import pytest
+from python_alfresco_api import ClientFactory, AuthUtil
+from python_alfresco_api.models import TicketBody
+
+class TestClientFactory:
+    """Test the client factory functionality"""
+    
+    def test_factory_creation(self):
+        """Test factory can be created"""
+        factory = ClientFactory("https://alfresco.example.com")
+        assert factory.base_url == "https://alfresco.example.com"
+    
+    def test_individual_client_creation(self):
+        """Test individual clients can be created"""
+        factory = ClientFactory("https://alfresco.example.com")
+        
+        auth_client = factory.create_auth_client()
+        core_client = factory.create_core_client()
+        discovery_client = factory.create_discovery_client()
+        
+        assert auth_client is not None
+        assert core_client is not None  
+        assert discovery_client is not None
+    
+    def test_all_clients_creation(self):
+        """Test all clients can be created at once"""
+        factory = ClientFactory("https://alfresco.example.com")
+        clients = factory.create_all_clients()
+        
+        expected_apis = ["auth", "core", "discovery", "search", "workflow", "model", "search_sql"]
+        for api in expected_apis:
+            assert api in clients
+            assert clients[api] is not None
+    
+    def test_master_client_creation(self):
+        """Test MasterClient creation and dot syntax access"""
+        factory = ClientFactory("https://alfresco.example.com")
+        master_client = factory.create_master_client()
+        
+        # Test MasterClient has all required attributes
+        assert hasattr(master_client, 'auth'), "MasterClient should have auth attribute"
+        assert hasattr(master_client, 'core'), "MasterClient should have core attribute"
+        assert hasattr(master_client, 'discovery'), "MasterClient should have discovery attribute"
+        assert hasattr(master_client, 'search'), "MasterClient should have search attribute"
+        assert hasattr(master_client, 'workflow'), "MasterClient should have workflow attribute"
+        assert hasattr(master_client, 'model'), "MasterClient should have model attribute"
+        assert hasattr(master_client, 'search_sql'), "MasterClient should have search_sql attribute"
+        
+        # Test that attributes are not None
+        assert master_client.auth is not None, "master_client.auth should not be None"
+        assert master_client.core is not None, "master_client.core should not be None"
+        assert master_client.search is not None, "master_client.search should not be None"
+    
+    def test_master_client_vs_individual_clients(self):
+        """Test that MasterClient provides same clients as individual creation"""
+        factory = ClientFactory("https://alfresco.example.com")
+        
+        # Create clients both ways
+        master_client = factory.create_master_client()
+        individual_auth = factory.create_auth_client()
+        
+        # Test that they're the same type of clients
+        assert type(master_client.auth) == type(individual_auth), "MasterClient.auth should be same type as individual auth client"
+
+class TestPydanticModels:
+    """Test Pydantic model functionality"""
+    
+    def test_ticket_body_creation(self):
+        """Test TicketBody model creation and validation"""
+        ticket_body = TicketBody(userId="admin", password="admin123")
+        
+        assert ticket_body.userId == "admin"
+        assert ticket_body.password == "admin123"
+        
+        # Test JSON serialization (perfect for LLMs)
+        json_data = ticket_body.model_dump_json()
+        assert "admin" in json_data
+        assert "admin123" in json_data
+    
+    def test_model_validation(self):
+        """Test Pydantic model validation"""
+        # This should work
+        valid_ticket = TicketBody(userId="test", password="test123")
+        assert valid_ticket.userId == "test"
+        
+        # Test that validation works (will depend on actual model constraints)
+        try:
+            # Empty userId should potentially fail validation
+            invalid_ticket = TicketBody(userId="", password="test")
+            # If this doesn't raise an error, validation might be lenient
+        except Exception:
+            # Validation worked as expected
+            pass
+
+class TestAuthUtil:
+    """Test authentication utility"""
+    
+    def test_auth_util_creation(self):
+        """Test AuthUtil can be created"""
+        auth = AuthUtil(
+            "https://alfresco.example.com",
+            "admin", 
+            "admin123"
+        )
+        
+        assert auth.base_url == "https://alfresco.example.com"
+        assert auth.username == "admin"
+        assert not auth.is_authenticated()  # Not authenticated initially
+
+if __name__ == "__main__":
+    pytest.main([__file__])