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

python_alfresco_api/raw_clients/alfresco_core_client/core_client/models/action_parameter_definition.py

@@ -0,0 +1,95 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ActionParameterDefinition")
+
+
+@_attrs_define
+class ActionParameterDefinition:
+    """
+    Attributes:
+        display_label (Union[Unset, str]):
+        mandatory (Union[Unset, bool]):
+        multi_valued (Union[Unset, bool]):
+        name (Union[Unset, str]):
+        type_ (Union[Unset, str]):
+    """
+
+    display_label: Union[Unset, str] = UNSET
+    mandatory: Union[Unset, bool] = UNSET
+    multi_valued: Union[Unset, bool] = UNSET
+    name: Union[Unset, str] = UNSET
+    type_: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        display_label = self.display_label
+
+        mandatory = self.mandatory
+
+        multi_valued = self.multi_valued
+
+        name = self.name
+
+        type_ = self.type_
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if display_label is not UNSET:
+            field_dict["displayLabel"] = display_label
+        if mandatory is not UNSET:
+            field_dict["mandatory"] = mandatory
+        if multi_valued is not UNSET:
+            field_dict["multiValued"] = multi_valued
+        if name is not UNSET:
+            field_dict["name"] = name
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        display_label = d.pop("displayLabel", UNSET)
+
+        mandatory = d.pop("mandatory", UNSET)
+
+        multi_valued = d.pop("multiValued", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        type_ = d.pop("type", UNSET)
+
+        action_parameter_definition = cls(
+            display_label=display_label,
+            mandatory=mandatory,
+            multi_valued=multi_valued,
+            name=name,
+            type_=type_,
+        )
+
+        action_parameter_definition.additional_properties = d
+        return action_parameter_definition
+
+    @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_core_client/core_client/models/activity.py

@@ -0,0 +1,137 @@
+import datetime
+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 dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.activity_activity_summary import ActivityActivitySummary
+
+
+T = TypeVar("T", bound="Activity")
+
+
+@_attrs_define
+class Activity:
+    """Activities describe any past activity in a site,
+    for example creating an item of content, commenting on a node,
+    liking an item of content.
+
+        Attributes:
+            activity_type (str): The type of the activity posted
+            feed_person_id (str): The feed on which this activity was posted
+            id (int): The unique id of the activity
+            post_person_id (str): The id of the person who performed the activity
+            activity_summary (Union[Unset, ActivityActivitySummary]): An object summarizing the activity
+            posted_at (Union[Unset, datetime.datetime]): The date time at which the activity was performed
+            site_id (Union[Unset, str]): The unique id of the site on which the activity was performed
+    """
+
+    activity_type: str
+    feed_person_id: str
+    id: int
+    post_person_id: str
+    activity_summary: Union[Unset, "ActivityActivitySummary"] = UNSET
+    posted_at: Union[Unset, datetime.datetime] = UNSET
+    site_id: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        activity_type = self.activity_type
+
+        feed_person_id = self.feed_person_id
+
+        id = self.id
+
+        post_person_id = self.post_person_id
+
+        activity_summary: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.activity_summary, Unset):
+            activity_summary = self.activity_summary.to_dict()
+
+        posted_at: Union[Unset, str] = UNSET
+        if not isinstance(self.posted_at, Unset):
+            posted_at = self.posted_at.isoformat()
+
+        site_id = self.site_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "activityType": activity_type,
+                "feedPersonId": feed_person_id,
+                "id": id,
+                "postPersonId": post_person_id,
+            }
+        )
+        if activity_summary is not UNSET:
+            field_dict["activitySummary"] = activity_summary
+        if posted_at is not UNSET:
+            field_dict["postedAt"] = posted_at
+        if site_id is not UNSET:
+            field_dict["siteId"] = site_id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.activity_activity_summary import ActivityActivitySummary
+
+        d = dict(src_dict)
+        activity_type = d.pop("activityType")
+
+        feed_person_id = d.pop("feedPersonId")
+
+        id = d.pop("id")
+
+        post_person_id = d.pop("postPersonId")
+
+        _activity_summary = d.pop("activitySummary", UNSET)
+        activity_summary: Union[Unset, ActivityActivitySummary]
+        if isinstance(_activity_summary, Unset):
+            activity_summary = UNSET
+        else:
+            activity_summary = ActivityActivitySummary.from_dict(_activity_summary)
+
+        _posted_at = d.pop("postedAt", UNSET)
+        posted_at: Union[Unset, datetime.datetime]
+        if isinstance(_posted_at, Unset):
+            posted_at = UNSET
+        else:
+            posted_at = isoparse(_posted_at)
+
+        site_id = d.pop("siteId", UNSET)
+
+        activity = cls(
+            activity_type=activity_type,
+            feed_person_id=feed_person_id,
+            id=id,
+            post_person_id=post_person_id,
+            activity_summary=activity_summary,
+            posted_at=posted_at,
+            site_id=site_id,
+        )
+
+        activity.additional_properties = d
+        return activity
+
+    @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_core_client/core_client/models/activity_activity_summary.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ActivityActivitySummary")
+
+
+@_attrs_define
+class ActivityActivitySummary:
+    """An object summarizing the activity"""
+
+    additional_properties: dict[str, str] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        activity_activity_summary = cls()
+
+        activity_activity_summary.additional_properties = d
+        return activity_activity_summary
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> 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_core_client/core_client/models/activity_entry.py

@@ -0,0 +1,67 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.activity import Activity
+
+
+T = TypeVar("T", bound="ActivityEntry")
+
+
+@_attrs_define
+class ActivityEntry:
+    """
+    Attributes:
+        entry (Activity): Activities describe any past activity in a site,
+            for example creating an item of content, commenting on a node,
+            liking an item of content.
+    """
+
+    entry: "Activity"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        entry = self.entry.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "entry": entry,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.activity import Activity
+
+        d = dict(src_dict)
+        entry = Activity.from_dict(d.pop("entry"))
+
+        activity_entry = cls(
+            entry=entry,
+        )
+
+        activity_entry.additional_properties = d
+        return activity_entry
+
+    @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_core_client/core_client/models/activity_paging.py

@@ -0,0 +1,65 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.activity_paging_list import ActivityPagingList
+
+
+T = TypeVar("T", bound="ActivityPaging")
+
+
+@_attrs_define
+class ActivityPaging:
+    """
+    Attributes:
+        list_ (ActivityPagingList):
+    """
+
+    list_: "ActivityPagingList"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        list_ = self.list_.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "list": list_,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.activity_paging_list import ActivityPagingList
+
+        d = dict(src_dict)
+        list_ = ActivityPagingList.from_dict(d.pop("list"))
+
+        activity_paging = cls(
+            list_=list_,
+        )
+
+        activity_paging.additional_properties = d
+        return activity_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_core_client/core_client/models/activity_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.activity_entry import ActivityEntry
+    from ..models.pagination import Pagination
+
+
+T = TypeVar("T", bound="ActivityPagingList")
+
+
+@_attrs_define
+class ActivityPagingList:
+    """
+    Attributes:
+        entries (Union[Unset, list['ActivityEntry']]):
+        pagination (Union[Unset, Pagination]):
+    """
+
+    entries: Union[Unset, list["ActivityEntry"]] = 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.activity_entry import ActivityEntry
+        from ..models.pagination import Pagination
+
+        d = dict(src_dict)
+        entries = []
+        _entries = d.pop("entries", UNSET)
+        for entries_item_data in _entries or []:
+            entries_item = ActivityEntry.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)
+
+        activity_paging_list = cls(
+            entries=entries,
+            pagination=pagination,
+        )
+
+        activity_paging_list.additional_properties = d
+        return activity_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_core_client/core_client/models/association.py

@@ -0,0 +1,67 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="Association")
+
+
+@_attrs_define
+class Association:
+    """
+    Attributes:
+        assoc_type (str):
+        target_id (str):
+    """
+
+    assoc_type: str
+    target_id: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        assoc_type = self.assoc_type
+
+        target_id = self.target_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "assocType": assoc_type,
+                "targetId": target_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        assoc_type = d.pop("assocType")
+
+        target_id = d.pop("targetId")
+
+        association = cls(
+            assoc_type=assoc_type,
+            target_id=target_id,
+        )
+
+        association.additional_properties = d
+        return association
+
+    @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_core_client/core_client/models/association_body.py

@@ -0,0 +1,67 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="AssociationBody")
+
+
+@_attrs_define
+class AssociationBody:
+    """
+    Attributes:
+        assoc_type (str):
+        target_id (str):
+    """
+
+    assoc_type: str
+    target_id: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        assoc_type = self.assoc_type
+
+        target_id = self.target_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "assocType": assoc_type,
+                "targetId": target_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        assoc_type = d.pop("assocType")
+
+        target_id = d.pop("targetId")
+
+        association_body = cls(
+            assoc_type=assoc_type,
+            target_id=target_id,
+        )
+
+        association_body.additional_properties = d
+        return association_body
+
+    @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_core_client/core_client/models/association_entry.py

@@ -0,0 +1,65 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.association import Association
+
+
+T = TypeVar("T", bound="AssociationEntry")
+
+
+@_attrs_define
+class AssociationEntry:
+    """
+    Attributes:
+        entry (Association):
+    """
+
+    entry: "Association"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        entry = self.entry.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "entry": entry,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.association import Association
+
+        d = dict(src_dict)
+        entry = Association.from_dict(d.pop("entry"))
+
+        association_entry = cls(
+            entry=entry,
+        )
+
+        association_entry.additional_properties = d
+        return association_entry
+
+    @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