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

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

@@ -0,0 +1,181 @@
+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.generic_facet_response import GenericFacetResponse
+    from ..models.response_consistency import ResponseConsistency
+    from ..models.result_buckets import ResultBuckets
+    from ..models.result_set_context_facet_queries_item import ResultSetContextFacetQueriesItem
+    from ..models.result_set_context_spellcheck_item import ResultSetContextSpellcheckItem
+    from ..models.search_request import SearchRequest
+
+
+T = TypeVar("T", bound="ResultSetContext")
+
+
+@_attrs_define
+class ResultSetContext:
+    """Context that applies to the whole result set
+
+    Attributes:
+        consistency (Union[Unset, ResponseConsistency]): The consistency state of the index used to execute the query
+        facet_queries (Union[Unset, list['ResultSetContextFacetQueriesItem']]): The counts from facet queries
+        facets (Union[Unset, list['GenericFacetResponse']]): The faceted response
+        facets_fields (Union[Unset, list['ResultBuckets']]): The counts from field facets
+        request (Union[Unset, SearchRequest]):
+        spellcheck (Union[Unset, list['ResultSetContextSpellcheckItem']]): Suggested corrections
+
+            If zero results were found for the original query then a single entry of type "searchInsteadFor" will be
+            returned.
+            If alternatives were found that return more results than the original query they are returned as "didYouMean"
+            options.
+            The highest quality suggestion is first.
+    """
+
+    consistency: Union[Unset, "ResponseConsistency"] = UNSET
+    facet_queries: Union[Unset, list["ResultSetContextFacetQueriesItem"]] = UNSET
+    facets: Union[Unset, list["GenericFacetResponse"]] = UNSET
+    facets_fields: Union[Unset, list["ResultBuckets"]] = UNSET
+    request: Union[Unset, "SearchRequest"] = UNSET
+    spellcheck: Union[Unset, list["ResultSetContextSpellcheckItem"]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        consistency: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.consistency, Unset):
+            consistency = self.consistency.to_dict()
+
+        facet_queries: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.facet_queries, Unset):
+            facet_queries = []
+            for facet_queries_item_data in self.facet_queries:
+                facet_queries_item = facet_queries_item_data.to_dict()
+                facet_queries.append(facet_queries_item)
+
+        facets: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.facets, Unset):
+            facets = []
+            for facets_item_data in self.facets:
+                facets_item = facets_item_data.to_dict()
+                facets.append(facets_item)
+
+        facets_fields: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.facets_fields, Unset):
+            facets_fields = []
+            for facets_fields_item_data in self.facets_fields:
+                facets_fields_item = facets_fields_item_data.to_dict()
+                facets_fields.append(facets_fields_item)
+
+        request: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.request, Unset):
+            request = self.request.to_dict()
+
+        spellcheck: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.spellcheck, Unset):
+            spellcheck = []
+            for spellcheck_item_data in self.spellcheck:
+                spellcheck_item = spellcheck_item_data.to_dict()
+                spellcheck.append(spellcheck_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if consistency is not UNSET:
+            field_dict["consistency"] = consistency
+        if facet_queries is not UNSET:
+            field_dict["facetQueries"] = facet_queries
+        if facets is not UNSET:
+            field_dict["facets"] = facets
+        if facets_fields is not UNSET:
+            field_dict["facetsFields"] = facets_fields
+        if request is not UNSET:
+            field_dict["request"] = request
+        if spellcheck is not UNSET:
+            field_dict["spellcheck"] = spellcheck
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.generic_facet_response import GenericFacetResponse
+        from ..models.response_consistency import ResponseConsistency
+        from ..models.result_buckets import ResultBuckets
+        from ..models.result_set_context_facet_queries_item import ResultSetContextFacetQueriesItem
+        from ..models.result_set_context_spellcheck_item import ResultSetContextSpellcheckItem
+        from ..models.search_request import SearchRequest
+
+        d = dict(src_dict)
+        _consistency = d.pop("consistency", UNSET)
+        consistency: Union[Unset, ResponseConsistency]
+        if isinstance(_consistency, Unset):
+            consistency = UNSET
+        else:
+            consistency = ResponseConsistency.from_dict(_consistency)
+
+        facet_queries = []
+        _facet_queries = d.pop("facetQueries", UNSET)
+        for facet_queries_item_data in _facet_queries or []:
+            facet_queries_item = ResultSetContextFacetQueriesItem.from_dict(facet_queries_item_data)
+
+            facet_queries.append(facet_queries_item)
+
+        facets = []
+        _facets = d.pop("facets", UNSET)
+        for facets_item_data in _facets or []:
+            facets_item = GenericFacetResponse.from_dict(facets_item_data)
+
+            facets.append(facets_item)
+
+        facets_fields = []
+        _facets_fields = d.pop("facetsFields", UNSET)
+        for facets_fields_item_data in _facets_fields or []:
+            facets_fields_item = ResultBuckets.from_dict(facets_fields_item_data)
+
+            facets_fields.append(facets_fields_item)
+
+        _request = d.pop("request", UNSET)
+        request: Union[Unset, SearchRequest]
+        if isinstance(_request, Unset):
+            request = UNSET
+        else:
+            request = SearchRequest.from_dict(_request)
+
+        spellcheck = []
+        _spellcheck = d.pop("spellcheck", UNSET)
+        for spellcheck_item_data in _spellcheck or []:
+            spellcheck_item = ResultSetContextSpellcheckItem.from_dict(spellcheck_item_data)
+
+            spellcheck.append(spellcheck_item)
+
+        result_set_context = cls(
+            consistency=consistency,
+            facet_queries=facet_queries,
+            facets=facets,
+            facets_fields=facets_fields,
+            request=request,
+            spellcheck=spellcheck,
+        )
+
+        result_set_context.additional_properties = d
+        return result_set_context
+
+    @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/result_set_context_facet_queries_item.py

@@ -0,0 +1,77 @@
+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="ResultSetContextFacetQueriesItem")
+
+
+@_attrs_define
+class ResultSetContextFacetQueriesItem:
+    """
+    Attributes:
+        count (Union[Unset, int]):
+        filter_query (Union[Unset, str]): The filter query you can use to apply this facet
+        label (Union[Unset, str]):
+    """
+
+    count: Union[Unset, int] = UNSET
+    filter_query: Union[Unset, str] = UNSET
+    label: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        count = self.count
+
+        filter_query = self.filter_query
+
+        label = self.label
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if count is not UNSET:
+            field_dict["count"] = count
+        if filter_query is not UNSET:
+            field_dict["filterQuery"] = filter_query
+        if label is not UNSET:
+            field_dict["label"] = label
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        count = d.pop("count", UNSET)
+
+        filter_query = d.pop("filterQuery", UNSET)
+
+        label = d.pop("label", UNSET)
+
+        result_set_context_facet_queries_item = cls(
+            count=count,
+            filter_query=filter_query,
+            label=label,
+        )
+
+        result_set_context_facet_queries_item.additional_properties = d
+        return result_set_context_facet_queries_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/result_set_context_spellcheck_item.py

@@ -0,0 +1,78 @@
+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 ..models.result_set_context_spellcheck_item_type import ResultSetContextSpellcheckItemType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ResultSetContextSpellcheckItem")
+
+
+@_attrs_define
+class ResultSetContextSpellcheckItem:
+    """
+    Attributes:
+        suggestion (Union[Unset, list[str]]): A suggested alternative query
+        type_ (Union[Unset, ResultSetContextSpellcheckItemType]):
+    """
+
+    suggestion: Union[Unset, list[str]] = UNSET
+    type_: Union[Unset, ResultSetContextSpellcheckItemType] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        suggestion: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.suggestion, Unset):
+            suggestion = self.suggestion
+
+        type_: Union[Unset, str] = UNSET
+        if not isinstance(self.type_, Unset):
+            type_ = self.type_.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if suggestion is not UNSET:
+            field_dict["suggestion"] = suggestion
+        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)
+        suggestion = cast(list[str], d.pop("suggestion", UNSET))
+
+        _type_ = d.pop("type", UNSET)
+        type_: Union[Unset, ResultSetContextSpellcheckItemType]
+        if isinstance(_type_, Unset):
+            type_ = UNSET
+        else:
+            type_ = ResultSetContextSpellcheckItemType(_type_)
+
+        result_set_context_spellcheck_item = cls(
+            suggestion=suggestion,
+            type_=type_,
+        )
+
+        result_set_context_spellcheck_item.additional_properties = d
+        return result_set_context_spellcheck_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/result_set_context_spellcheck_item_type.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ResultSetContextSpellcheckItemType(str, Enum):
+    DIDYOUMEAN = "didYouMean"
+    SEARCHINSTEADFOR = "searchInsteadFor"
+
+    def __str__(self) -> str:
+        return str(self.value)

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

@@ -0,0 +1,73 @@
+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.result_set_paging_list import ResultSetPagingList
+
+
+T = TypeVar("T", bound="ResultSetPaging")
+
+
+@_attrs_define
+class ResultSetPaging:
+    """Query results
+
+    Attributes:
+        list_ (Union[Unset, ResultSetPagingList]):
+    """
+
+    list_: Union[Unset, "ResultSetPagingList"] = 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.result_set_paging_list import ResultSetPagingList
+
+        d = dict(src_dict)
+        _list_ = d.pop("list", UNSET)
+        list_: Union[Unset, ResultSetPagingList]
+        if isinstance(_list_, Unset):
+            list_ = UNSET
+        else:
+            list_ = ResultSetPagingList.from_dict(_list_)
+
+        result_set_paging = cls(
+            list_=list_,
+        )
+
+        result_set_paging.additional_properties = d
+        return result_set_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_search_client/search_client/models/result_set_paging_list.py

@@ -0,0 +1,111 @@
+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.result_set_context import ResultSetContext
+    from ..models.result_set_row_entry import ResultSetRowEntry
+
+
+T = TypeVar("T", bound="ResultSetPagingList")
+
+
+@_attrs_define
+class ResultSetPagingList:
+    """
+    Attributes:
+        context (Union[Unset, ResultSetContext]): Context that applies to the whole result set
+        entries (Union[Unset, list['ResultSetRowEntry']]):
+        pagination (Union[Unset, Pagination]):
+    """
+
+    context: Union[Unset, "ResultSetContext"] = UNSET
+    entries: Union[Unset, list["ResultSetRowEntry"]] = UNSET
+    pagination: Union[Unset, "Pagination"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        context: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.context, Unset):
+            context = self.context.to_dict()
+
+        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 context is not UNSET:
+            field_dict["context"] = context
+        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.result_set_context import ResultSetContext
+        from ..models.result_set_row_entry import ResultSetRowEntry
+
+        d = dict(src_dict)
+        _context = d.pop("context", UNSET)
+        context: Union[Unset, ResultSetContext]
+        if isinstance(_context, Unset):
+            context = UNSET
+        else:
+            context = ResultSetContext.from_dict(_context)
+
+        entries = []
+        _entries = d.pop("entries", UNSET)
+        for entries_item_data in _entries or []:
+            entries_item = ResultSetRowEntry.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)
+
+        result_set_paging_list = cls(
+            context=context,
+            entries=entries,
+            pagination=pagination,
+        )
+
+        result_set_paging_list.additional_properties = d
+        return result_set_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_search_client/search_client/models/result_set_row_entry.py

@@ -0,0 +1,66 @@
+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.result_node import ResultNode
+
+
+T = TypeVar("T", bound="ResultSetRowEntry")
+
+
+@_attrs_define
+class ResultSetRowEntry:
+    """A row in the result set
+
+    Attributes:
+        entry (ResultNode):
+    """
+
+    entry: "ResultNode"
+    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.result_node import ResultNode
+
+        d = dict(src_dict)
+        entry = ResultNode.from_dict(d.pop("entry"))
+
+        result_set_row_entry = cls(
+            entry=entry,
+        )
+
+        result_set_row_entry.additional_properties = d
+        return result_set_row_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_search_client/search_client/models/search_entry.py

@@ -0,0 +1,85 @@
+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.search_entry_highlight_item import SearchEntryHighlightItem
+
+
+T = TypeVar("T", bound="SearchEntry")
+
+
+@_attrs_define
+class SearchEntry:
+    """
+    Attributes:
+        highlight (Union[Unset, list['SearchEntryHighlightItem']]): Highlight fragments if requested and available. A
+            match can happen in any of the requested field.
+        score (Union[Unset, float]): The score for this row
+    """
+
+    highlight: Union[Unset, list["SearchEntryHighlightItem"]] = UNSET
+    score: Union[Unset, float] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        highlight: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.highlight, Unset):
+            highlight = []
+            for highlight_item_data in self.highlight:
+                highlight_item = highlight_item_data.to_dict()
+                highlight.append(highlight_item)
+
+        score = self.score
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if highlight is not UNSET:
+            field_dict["highlight"] = highlight
+        if score is not UNSET:
+            field_dict["score"] = score
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.search_entry_highlight_item import SearchEntryHighlightItem
+
+        d = dict(src_dict)
+        highlight = []
+        _highlight = d.pop("highlight", UNSET)
+        for highlight_item_data in _highlight or []:
+            highlight_item = SearchEntryHighlightItem.from_dict(highlight_item_data)
+
+            highlight.append(highlight_item)
+
+        score = d.pop("score", UNSET)
+
+        search_entry = cls(
+            highlight=highlight,
+            score=score,
+        )
+
+        search_entry.additional_properties = d
+        return search_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