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

python_alfresco_api/raw_clients/alfresco_search_client/search_client/models/request_highlight.py

@@ -0,0 +1,143 @@
+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.request_highlight_fields_item import RequestHighlightFieldsItem
+
+
+T = TypeVar("T", bound="RequestHighlight")
+
+
+@_attrs_define
+class RequestHighlight:
+    """Request that highlight fragments to be added to result set rows
+    The properties reflect SOLR highlighting parameters.
+
+        Attributes:
+            fields (Union[Unset, list['RequestHighlightFieldsItem']]): The fields to highlight and field specific
+                configuration properties for each field
+            fragment_size (Union[Unset, int]): The character length of each snippet.
+            max_analyzed_chars (Union[Unset, int]): The number of characters to be considered for highlighting. Matches
+                after this count will not be shown.
+            merge_contiguous (Union[Unset, bool]): If fragments over lap they can be  merged into one larger fragment
+            postfix (Union[Unset, str]): The string used to mark the end of a highlight in a fragment.
+            prefix (Union[Unset, str]): The string used to mark the start of a highlight in a fragment.
+            snippet_count (Union[Unset, int]): The maximum number of distinct highlight snippets to return for each
+                highlight field.
+            use_phrase_highlighter (Union[Unset, bool]): Should phrases be identified.
+    """
+
+    fields: Union[Unset, list["RequestHighlightFieldsItem"]] = UNSET
+    fragment_size: Union[Unset, int] = UNSET
+    max_analyzed_chars: Union[Unset, int] = UNSET
+    merge_contiguous: Union[Unset, bool] = UNSET
+    postfix: Union[Unset, str] = UNSET
+    prefix: Union[Unset, str] = UNSET
+    snippet_count: Union[Unset, int] = UNSET
+    use_phrase_highlighter: Union[Unset, bool] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        fields: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.fields, Unset):
+            fields = []
+            for fields_item_data in self.fields:
+                fields_item = fields_item_data.to_dict()
+                fields.append(fields_item)
+
+        fragment_size = self.fragment_size
+
+        max_analyzed_chars = self.max_analyzed_chars
+
+        merge_contiguous = self.merge_contiguous
+
+        postfix = self.postfix
+
+        prefix = self.prefix
+
+        snippet_count = self.snippet_count
+
+        use_phrase_highlighter = self.use_phrase_highlighter
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if fields is not UNSET:
+            field_dict["fields"] = fields
+        if fragment_size is not UNSET:
+            field_dict["fragmentSize"] = fragment_size
+        if max_analyzed_chars is not UNSET:
+            field_dict["maxAnalyzedChars"] = max_analyzed_chars
+        if merge_contiguous is not UNSET:
+            field_dict["mergeContiguous"] = merge_contiguous
+        if postfix is not UNSET:
+            field_dict["postfix"] = postfix
+        if prefix is not UNSET:
+            field_dict["prefix"] = prefix
+        if snippet_count is not UNSET:
+            field_dict["snippetCount"] = snippet_count
+        if use_phrase_highlighter is not UNSET:
+            field_dict["usePhraseHighlighter"] = use_phrase_highlighter
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.request_highlight_fields_item import RequestHighlightFieldsItem
+
+        d = dict(src_dict)
+        fields = []
+        _fields = d.pop("fields", UNSET)
+        for fields_item_data in _fields or []:
+            fields_item = RequestHighlightFieldsItem.from_dict(fields_item_data)
+
+            fields.append(fields_item)
+
+        fragment_size = d.pop("fragmentSize", UNSET)
+
+        max_analyzed_chars = d.pop("maxAnalyzedChars", UNSET)
+
+        merge_contiguous = d.pop("mergeContiguous", UNSET)
+
+        postfix = d.pop("postfix", UNSET)
+
+        prefix = d.pop("prefix", UNSET)
+
+        snippet_count = d.pop("snippetCount", UNSET)
+
+        use_phrase_highlighter = d.pop("usePhraseHighlighter", UNSET)
+
+        request_highlight = cls(
+            fields=fields,
+            fragment_size=fragment_size,
+            max_analyzed_chars=max_analyzed_chars,
+            merge_contiguous=merge_contiguous,
+            postfix=postfix,
+            prefix=prefix,
+            snippet_count=snippet_count,
+            use_phrase_highlighter=use_phrase_highlighter,
+        )
+
+        request_highlight.additional_properties = d
+        return request_highlight
+
+    @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_search_client/search_client/models/request_highlight_fields_item.py

@@ -0,0 +1,104 @@
+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="RequestHighlightFieldsItem")
+
+
+@_attrs_define
+class RequestHighlightFieldsItem:
+    """
+    Attributes:
+        field (Union[Unset, str]): The name of the field to highlight.
+        fragment_size (Union[Unset, int]):
+        merge_contiguous (Union[Unset, bool]):
+        postfix (Union[Unset, str]):
+        prefix (Union[Unset, str]):
+        snippet_count (Union[Unset, int]):
+    """
+
+    field: Union[Unset, str] = UNSET
+    fragment_size: Union[Unset, int] = UNSET
+    merge_contiguous: Union[Unset, bool] = UNSET
+    postfix: Union[Unset, str] = UNSET
+    prefix: Union[Unset, str] = UNSET
+    snippet_count: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field = self.field
+
+        fragment_size = self.fragment_size
+
+        merge_contiguous = self.merge_contiguous
+
+        postfix = self.postfix
+
+        prefix = self.prefix
+
+        snippet_count = self.snippet_count
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if field is not UNSET:
+            field_dict["field"] = field
+        if fragment_size is not UNSET:
+            field_dict["fragmentSize"] = fragment_size
+        if merge_contiguous is not UNSET:
+            field_dict["mergeContiguous"] = merge_contiguous
+        if postfix is not UNSET:
+            field_dict["postfix"] = postfix
+        if prefix is not UNSET:
+            field_dict["prefix"] = prefix
+        if snippet_count is not UNSET:
+            field_dict["snippetCount"] = snippet_count
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        field = d.pop("field", UNSET)
+
+        fragment_size = d.pop("fragmentSize", UNSET)
+
+        merge_contiguous = d.pop("mergeContiguous", UNSET)
+
+        postfix = d.pop("postfix", UNSET)
+
+        prefix = d.pop("prefix", UNSET)
+
+        snippet_count = d.pop("snippetCount", UNSET)
+
+        request_highlight_fields_item = cls(
+            field=field,
+            fragment_size=fragment_size,
+            merge_contiguous=merge_contiguous,
+            postfix=postfix,
+            prefix=prefix,
+            snippet_count=snippet_count,
+        )
+
+        request_highlight_fields_item.additional_properties = d
+        return request_highlight_fields_item
+
+    @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_search_client/search_client/models/request_include_item.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class RequestIncludeItem(str, Enum):
+    ALLOWABLEOPERATIONS = "allowableOperations"
+    ASPECTNAMES = "aspectNames"
+    ISLINK = "isLink"
+    ISLOCKED = "isLocked"
+    PATH = "path"
+    PROPERTIES = "properties"
+
+    def __str__(self) -> str:
+        return str(self.value)

python_alfresco_api/raw_clients/alfresco_search_client/search_client/models/request_limits.py

@@ -0,0 +1,71 @@
+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="RequestLimits")
+
+
+@_attrs_define
+class RequestLimits:
+    """Limit the time and resources used for query execution
+
+    Attributes:
+        permission_evaluation_count (Union[Unset, int]): Maximum count of post query permission evaluations Default:
+            2000.
+        permission_evaluation_time (Union[Unset, int]): Maximum time for post query permission evaluation Default:
+            20000.
+    """
+
+    permission_evaluation_count: Union[Unset, int] = 2000
+    permission_evaluation_time: Union[Unset, int] = 20000
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        permission_evaluation_count = self.permission_evaluation_count
+
+        permission_evaluation_time = self.permission_evaluation_time
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if permission_evaluation_count is not UNSET:
+            field_dict["permissionEvaluationCount"] = permission_evaluation_count
+        if permission_evaluation_time is not UNSET:
+            field_dict["permissionEvaluationTime"] = permission_evaluation_time
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        permission_evaluation_count = d.pop("permissionEvaluationCount", UNSET)
+
+        permission_evaluation_time = d.pop("permissionEvaluationTime", UNSET)
+
+        request_limits = cls(
+            permission_evaluation_count=permission_evaluation_count,
+            permission_evaluation_time=permission_evaluation_time,
+        )
+
+        request_limits.additional_properties = d
+        return request_limits
+
+    @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_search_client/search_client/models/request_localization.py

@@ -0,0 +1,73 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="RequestLocalization")
+
+
+@_attrs_define
+class RequestLocalization:
+    """Localization settings
+
+    Attributes:
+        locales (Union[Unset, list[str]]): A list of Locales definied by IETF BCP 47.  The ordering is significant.  The
+            first locale (leftmost) is used for sort and query localization, whereas the remaining locales are used for
+            query only.
+        timezone (Union[Unset, str]): A valid timezone id supported by @see java.time.ZoneId
+    """
+
+    locales: Union[Unset, list[str]] = UNSET
+    timezone: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        locales: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.locales, Unset):
+            locales = self.locales
+
+        timezone = self.timezone
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if locales is not UNSET:
+            field_dict["locales"] = locales
+        if timezone is not UNSET:
+            field_dict["timezone"] = timezone
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        locales = cast(list[str], d.pop("locales", UNSET))
+
+        timezone = d.pop("timezone", UNSET)
+
+        request_localization = cls(
+            locales=locales,
+            timezone=timezone,
+        )
+
+        request_localization.additional_properties = d
+        return request_localization
+
+    @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_search_client/search_client/models/request_pagination.py

@@ -0,0 +1,68 @@
+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="RequestPagination")
+
+
+@_attrs_define
+class RequestPagination:
+    """
+    Attributes:
+        max_items (Union[Unset, int]): The maximum number of items to return in the query results Default: 100.
+        skip_count (Union[Unset, int]): The number of items to skip from the start of the query set Default: 0.
+    """
+
+    max_items: Union[Unset, int] = 100
+    skip_count: Union[Unset, int] = 0
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        max_items = self.max_items
+
+        skip_count = self.skip_count
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if max_items is not UNSET:
+            field_dict["maxItems"] = max_items
+        if skip_count is not UNSET:
+            field_dict["skipCount"] = skip_count
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        max_items = d.pop("maxItems", UNSET)
+
+        skip_count = d.pop("skipCount", UNSET)
+
+        request_pagination = cls(
+            max_items=max_items,
+            skip_count=skip_count,
+        )
+
+        request_pagination.additional_properties = d
+        return request_pagination
+
+    @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_search_client/search_client/models/request_pivot.py

@@ -0,0 +1,82 @@
+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="RequestPivot")
+
+
+@_attrs_define
+class RequestPivot:
+    """A list of pivots.
+
+    Example:
+        {'key': 'MyKey', 'pivots': [{'key': 'AnotherKey', 'pivots': []}]}
+
+    Attributes:
+        key (Union[Unset, str]): A key corresponding to a matching field facet label or stats.
+        pivots (Union[Unset, list['RequestPivot']]):
+    """
+
+    key: Union[Unset, str] = UNSET
+    pivots: Union[Unset, list["RequestPivot"]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        key = self.key
+
+        pivots: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.pivots, Unset):
+            pivots = []
+            for pivots_item_data in self.pivots:
+                pivots_item = pivots_item_data.to_dict()
+                pivots.append(pivots_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if key is not UNSET:
+            field_dict["key"] = key
+        if pivots is not UNSET:
+            field_dict["pivots"] = pivots
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        key = d.pop("key", UNSET)
+
+        pivots = []
+        _pivots = d.pop("pivots", UNSET)
+        for pivots_item_data in _pivots or []:
+            pivots_item = RequestPivot.from_dict(pivots_item_data)
+
+            pivots.append(pivots_item)
+
+        request_pivot = cls(
+            key=key,
+            pivots=pivots,
+        )
+
+        request_pivot.additional_properties = d
+        return request_pivot
+
+    @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_search_client/search_client/models/request_query.py

@@ -0,0 +1,89 @@
+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 ..models.request_query_language import RequestQueryLanguage
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="RequestQuery")
+
+
+@_attrs_define
+class RequestQuery:
+    """Query.
+
+    Attributes:
+        query (str): The query which may have been generated in some way from the userQuery
+        language (Union[Unset, RequestQueryLanguage]): The query language in which the query is written. Default:
+            RequestQueryLanguage.AFTS.
+        user_query (Union[Unset, str]): The exact search request typed in by the user
+    """
+
+    query: str
+    language: Union[Unset, RequestQueryLanguage] = RequestQueryLanguage.AFTS
+    user_query: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        query = self.query
+
+        language: Union[Unset, str] = UNSET
+        if not isinstance(self.language, Unset):
+            language = self.language.value
+
+        user_query = self.user_query
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "query": query,
+            }
+        )
+        if language is not UNSET:
+            field_dict["language"] = language
+        if user_query is not UNSET:
+            field_dict["userQuery"] = user_query
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        query = d.pop("query")
+
+        _language = d.pop("language", UNSET)
+        language: Union[Unset, RequestQueryLanguage]
+        if isinstance(_language, Unset):
+            language = UNSET
+        else:
+            language = RequestQueryLanguage(_language)
+
+        user_query = d.pop("userQuery", UNSET)
+
+        request_query = cls(
+            query=query,
+            language=language,
+            user_query=user_query,
+        )
+
+        request_query.additional_properties = d
+        return request_query
+
+    @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_search_client/search_client/models/request_query_language.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class RequestQueryLanguage(str, Enum):
+    AFTS = "afts"
+    CMIS = "cmis"
+    LUCENE = "lucene"
+
+    def __str__(self) -> str:
+        return str(self.value)