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

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

@@ -0,0 +1,172 @@
+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.request_facet_field_method import RequestFacetFieldMethod
+from ..models.request_facet_field_sort import RequestFacetFieldSort
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="RequestFacetField")
+
+
+@_attrs_define
+class RequestFacetField:
+    """A simple facet field
+
+    Attributes:
+        exclude_filters (Union[Unset, list[str]]): Filter Queries with tags listed here will not be included in facet
+            counts.
+            This is used for multi-select facetting.
+        facet_enum_cache_min_df (Union[Unset, int]):
+        field (Union[Unset, str]): The facet field
+        label (Union[Unset, str]): A label to include in place of the facet field
+        limit (Union[Unset, int]):
+        method (Union[Unset, RequestFacetFieldMethod]):
+        mincount (Union[Unset, int]): The minimum count required for a facet field to be included in the response.
+            Default: 1.
+        missing (Union[Unset, bool]): When true, count results that match the query but which have no facet value for
+            the field (in addition to the Term-based constraints). Default: False.
+        offset (Union[Unset, int]):
+        prefix (Union[Unset, str]): Restricts the possible constraints to only indexed values with a specified prefix.
+        sort (Union[Unset, RequestFacetFieldSort]):
+    """
+
+    exclude_filters: Union[Unset, list[str]] = UNSET
+    facet_enum_cache_min_df: Union[Unset, int] = UNSET
+    field: Union[Unset, str] = UNSET
+    label: Union[Unset, str] = UNSET
+    limit: Union[Unset, int] = UNSET
+    method: Union[Unset, RequestFacetFieldMethod] = UNSET
+    mincount: Union[Unset, int] = 1
+    missing: Union[Unset, bool] = False
+    offset: Union[Unset, int] = UNSET
+    prefix: Union[Unset, str] = UNSET
+    sort: Union[Unset, RequestFacetFieldSort] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        exclude_filters: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.exclude_filters, Unset):
+            exclude_filters = self.exclude_filters
+
+        facet_enum_cache_min_df = self.facet_enum_cache_min_df
+
+        field = self.field
+
+        label = self.label
+
+        limit = self.limit
+
+        method: Union[Unset, str] = UNSET
+        if not isinstance(self.method, Unset):
+            method = self.method.value
+
+        mincount = self.mincount
+
+        missing = self.missing
+
+        offset = self.offset
+
+        prefix = self.prefix
+
+        sort: Union[Unset, str] = UNSET
+        if not isinstance(self.sort, Unset):
+            sort = self.sort.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if exclude_filters is not UNSET:
+            field_dict["excludeFilters"] = exclude_filters
+        if facet_enum_cache_min_df is not UNSET:
+            field_dict["facetEnumCacheMinDf"] = facet_enum_cache_min_df
+        if field is not UNSET:
+            field_dict["field"] = field
+        if label is not UNSET:
+            field_dict["label"] = label
+        if limit is not UNSET:
+            field_dict["limit"] = limit
+        if method is not UNSET:
+            field_dict["method"] = method
+        if mincount is not UNSET:
+            field_dict["mincount"] = mincount
+        if missing is not UNSET:
+            field_dict["missing"] = missing
+        if offset is not UNSET:
+            field_dict["offset"] = offset
+        if prefix is not UNSET:
+            field_dict["prefix"] = prefix
+        if sort is not UNSET:
+            field_dict["sort"] = sort
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        exclude_filters = cast(list[str], d.pop("excludeFilters", UNSET))
+
+        facet_enum_cache_min_df = d.pop("facetEnumCacheMinDf", UNSET)
+
+        field = d.pop("field", UNSET)
+
+        label = d.pop("label", UNSET)
+
+        limit = d.pop("limit", UNSET)
+
+        _method = d.pop("method", UNSET)
+        method: Union[Unset, RequestFacetFieldMethod]
+        if isinstance(_method, Unset):
+            method = UNSET
+        else:
+            method = RequestFacetFieldMethod(_method)
+
+        mincount = d.pop("mincount", UNSET)
+
+        missing = d.pop("missing", UNSET)
+
+        offset = d.pop("offset", UNSET)
+
+        prefix = d.pop("prefix", UNSET)
+
+        _sort = d.pop("sort", UNSET)
+        sort: Union[Unset, RequestFacetFieldSort]
+        if isinstance(_sort, Unset):
+            sort = UNSET
+        else:
+            sort = RequestFacetFieldSort(_sort)
+
+        request_facet_field = cls(
+            exclude_filters=exclude_filters,
+            facet_enum_cache_min_df=facet_enum_cache_min_df,
+            field=field,
+            label=label,
+            limit=limit,
+            method=method,
+            mincount=mincount,
+            missing=missing,
+            offset=offset,
+            prefix=prefix,
+            sort=sort,
+        )
+
+        request_facet_field.additional_properties = d
+        return request_facet_field
+
+    @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_facet_field_method.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class RequestFacetFieldMethod(str, Enum):
+    ENUM = "ENUM"
+    FC = "FC"
+
+    def __str__(self) -> str:
+        return str(self.value)

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

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class RequestFacetFieldSort(str, Enum):
+    COUNT = "COUNT"
+    INDEX = "INDEX"
+
+    def __str__(self) -> str:
+        return str(self.value)

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

@@ -0,0 +1,79 @@
+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_facet_field import RequestFacetField
+
+
+T = TypeVar("T", bound="RequestFacetFields")
+
+
+@_attrs_define
+class RequestFacetFields:
+    """Simple facet fields to include
+    The Properties reflect the global properties related to field facts in SOLR.
+    They are descripbed in detail by the SOLR documentation
+
+        Attributes:
+            facets (Union[Unset, list['RequestFacetField']]): Define specifc fields on which to facet (adds SOLR facet.field
+                and f.<field>.facet.* options)
+    """
+
+    facets: Union[Unset, list["RequestFacetField"]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        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)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if facets is not UNSET:
+            field_dict["facets"] = facets
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.request_facet_field import RequestFacetField
+
+        d = dict(src_dict)
+        facets = []
+        _facets = d.pop("facets", UNSET)
+        for facets_item_data in _facets or []:
+            facets_item = RequestFacetField.from_dict(facets_item_data)
+
+            facets.append(facets_item)
+
+        request_facet_fields = cls(
+            facets=facets,
+        )
+
+        request_facet_fields.additional_properties = d
+        return request_facet_fields
+
+    @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_facet_intervals.py

@@ -0,0 +1,97 @@
+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_facet_intervals_intervals_item import RequestFacetIntervalsIntervalsItem
+    from ..models.request_facet_set import RequestFacetSet
+
+
+T = TypeVar("T", bound="RequestFacetIntervals")
+
+
+@_attrs_define
+class RequestFacetIntervals:
+    """Facet Intervals
+
+    Attributes:
+        intervals (Union[Unset, list['RequestFacetIntervalsIntervalsItem']]): Specifies the fields to facet by interval.
+        sets (Union[Unset, list['RequestFacetSet']]): Sets the intervals for all fields.
+    """
+
+    intervals: Union[Unset, list["RequestFacetIntervalsIntervalsItem"]] = UNSET
+    sets: Union[Unset, list["RequestFacetSet"]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        intervals: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.intervals, Unset):
+            intervals = []
+            for intervals_item_data in self.intervals:
+                intervals_item = intervals_item_data.to_dict()
+                intervals.append(intervals_item)
+
+        sets: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.sets, Unset):
+            sets = []
+            for sets_item_data in self.sets:
+                sets_item = sets_item_data.to_dict()
+                sets.append(sets_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if intervals is not UNSET:
+            field_dict["intervals"] = intervals
+        if sets is not UNSET:
+            field_dict["sets"] = sets
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.request_facet_intervals_intervals_item import RequestFacetIntervalsIntervalsItem
+        from ..models.request_facet_set import RequestFacetSet
+
+        d = dict(src_dict)
+        intervals = []
+        _intervals = d.pop("intervals", UNSET)
+        for intervals_item_data in _intervals or []:
+            intervals_item = RequestFacetIntervalsIntervalsItem.from_dict(intervals_item_data)
+
+            intervals.append(intervals_item)
+
+        sets = []
+        _sets = d.pop("sets", UNSET)
+        for sets_item_data in _sets or []:
+            sets_item = RequestFacetSet.from_dict(sets_item_data)
+
+            sets.append(sets_item)
+
+        request_facet_intervals = cls(
+            intervals=intervals,
+            sets=sets,
+        )
+
+        request_facet_intervals.additional_properties = d
+        return request_facet_intervals
+
+    @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_facet_intervals_intervals_item.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.request_facet_set import RequestFacetSet
+
+
+T = TypeVar("T", bound="RequestFacetIntervalsIntervalsItem")
+
+
+@_attrs_define
+class RequestFacetIntervalsIntervalsItem:
+    """
+    Attributes:
+        field (Union[Unset, str]): The field to facet on
+        label (Union[Unset, str]): A label to use to identify the field facet
+        sets (Union[Unset, list['RequestFacetSet']]): Sets the intervals for all fields.
+    """
+
+    field: Union[Unset, str] = UNSET
+    label: Union[Unset, str] = UNSET
+    sets: Union[Unset, list["RequestFacetSet"]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field = self.field
+
+        label = self.label
+
+        sets: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.sets, Unset):
+            sets = []
+            for sets_item_data in self.sets:
+                sets_item = sets_item_data.to_dict()
+                sets.append(sets_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if field is not UNSET:
+            field_dict["field"] = field
+        if label is not UNSET:
+            field_dict["label"] = label
+        if sets is not UNSET:
+            field_dict["sets"] = sets
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.request_facet_set import RequestFacetSet
+
+        d = dict(src_dict)
+        field = d.pop("field", UNSET)
+
+        label = d.pop("label", UNSET)
+
+        sets = []
+        _sets = d.pop("sets", UNSET)
+        for sets_item_data in _sets or []:
+            sets_item = RequestFacetSet.from_dict(sets_item_data)
+
+            sets.append(sets_item)
+
+        request_facet_intervals_intervals_item = cls(
+            field=field,
+            label=label,
+            sets=sets,
+        )
+
+        request_facet_intervals_intervals_item.additional_properties = d
+        return request_facet_intervals_intervals_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_facet_queries_item.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="RequestFacetQueriesItem")
+
+
+@_attrs_define
+class RequestFacetQueriesItem:
+    """
+    Attributes:
+        label (Union[Unset, str]): A label to include in place of the facet query
+        query (Union[Unset, str]): A facet query
+    """
+
+    label: Union[Unset, str] = UNSET
+    query: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        label = self.label
+
+        query = self.query
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if label is not UNSET:
+            field_dict["label"] = label
+        if query is not UNSET:
+            field_dict["query"] = query
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        label = d.pop("label", UNSET)
+
+        query = d.pop("query", UNSET)
+
+        request_facet_queries_item = cls(
+            label=label,
+            query=query,
+        )
+
+        request_facet_queries_item.additional_properties = d
+        return request_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/request_facet_set.py

@@ -0,0 +1,98 @@
+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="RequestFacetSet")
+
+
+@_attrs_define
+class RequestFacetSet:
+    """The interval to Set
+
+    Attributes:
+        end (Union[Unset, str]): The end of the range
+        end_inclusive (Union[Unset, bool]): When true, the set will include values less than or equal to "end" Default:
+            True.
+        label (Union[Unset, str]): A label to use to identify the set
+        start (Union[Unset, str]): The start of the range
+        start_inclusive (Union[Unset, bool]): When true, the set will include values greater or equal to "start"
+            Default: True.
+    """
+
+    end: Union[Unset, str] = UNSET
+    end_inclusive: Union[Unset, bool] = True
+    label: Union[Unset, str] = UNSET
+    start: Union[Unset, str] = UNSET
+    start_inclusive: Union[Unset, bool] = True
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        end = self.end
+
+        end_inclusive = self.end_inclusive
+
+        label = self.label
+
+        start = self.start
+
+        start_inclusive = self.start_inclusive
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if end is not UNSET:
+            field_dict["end"] = end
+        if end_inclusive is not UNSET:
+            field_dict["endInclusive"] = end_inclusive
+        if label is not UNSET:
+            field_dict["label"] = label
+        if start is not UNSET:
+            field_dict["start"] = start
+        if start_inclusive is not UNSET:
+            field_dict["startInclusive"] = start_inclusive
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        end = d.pop("end", UNSET)
+
+        end_inclusive = d.pop("endInclusive", UNSET)
+
+        label = d.pop("label", UNSET)
+
+        start = d.pop("start", UNSET)
+
+        start_inclusive = d.pop("startInclusive", UNSET)
+
+        request_facet_set = cls(
+            end=end,
+            end_inclusive=end_inclusive,
+            label=label,
+            start=start,
+            start_inclusive=start_inclusive,
+        )
+
+        request_facet_set.additional_properties = d
+        return request_facet_set
+
+    @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_filter_queries_item.py

@@ -0,0 +1,72 @@
+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="RequestFilterQueriesItem")
+
+
+@_attrs_define
+class RequestFilterQueriesItem:
+    """
+    Attributes:
+        query (Union[Unset, str]): The filter query expression.
+            For multi-select facets selected facets must be order together
+        tags (Union[Unset, list[str]]): Tags used exclude the filters from facet evaluation for multi-select facet
+            support
+    """
+
+    query: Union[Unset, str] = UNSET
+    tags: Union[Unset, list[str]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        query = self.query
+
+        tags: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.tags, Unset):
+            tags = self.tags
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if query is not UNSET:
+            field_dict["query"] = query
+        if tags is not UNSET:
+            field_dict["tags"] = tags
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        query = d.pop("query", UNSET)
+
+        tags = cast(list[str], d.pop("tags", UNSET))
+
+        request_filter_queries_item = cls(
+            query=query,
+            tags=tags,
+        )
+
+        request_filter_queries_item.additional_properties = d
+        return request_filter_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