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

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

@@ -0,0 +1,139 @@
+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="RequestRange")
+
+
+@_attrs_define
+class RequestRange:
+    """Facet range
+
+    Attributes:
+        end (Union[Unset, str]): The end of the range
+        exclude_filters (Union[Unset, list[str]]): Filter queries to exclude when calculating statistics
+        field (Union[Unset, str]): The name of the field to perform range
+        gap (Union[Unset, str]): Bucket size
+        hardend (Union[Unset, bool]): If true means that the last bucket will end at “end” even if it is less than “gap”
+            wide.
+        include (Union[Unset, list[str]]): lower, upper, edge, outer, all
+        label (Union[Unset, str]): A label to include as a pivot reference
+        other (Union[Unset, list[str]]): before, after, between, non, all
+        start (Union[Unset, str]): The start of the range
+    """
+
+    end: Union[Unset, str] = UNSET
+    exclude_filters: Union[Unset, list[str]] = UNSET
+    field: Union[Unset, str] = UNSET
+    gap: Union[Unset, str] = UNSET
+    hardend: Union[Unset, bool] = UNSET
+    include: Union[Unset, list[str]] = UNSET
+    label: Union[Unset, str] = UNSET
+    other: Union[Unset, list[str]] = UNSET
+    start: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        end = self.end
+
+        exclude_filters: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.exclude_filters, Unset):
+            exclude_filters = self.exclude_filters
+
+        field = self.field
+
+        gap = self.gap
+
+        hardend = self.hardend
+
+        include: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.include, Unset):
+            include = self.include
+
+        label = self.label
+
+        other: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.other, Unset):
+            other = self.other
+
+        start = self.start
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if end is not UNSET:
+            field_dict["end"] = end
+        if exclude_filters is not UNSET:
+            field_dict["excludeFilters"] = exclude_filters
+        if field is not UNSET:
+            field_dict["field"] = field
+        if gap is not UNSET:
+            field_dict["gap"] = gap
+        if hardend is not UNSET:
+            field_dict["hardend"] = hardend
+        if include is not UNSET:
+            field_dict["include"] = include
+        if label is not UNSET:
+            field_dict["label"] = label
+        if other is not UNSET:
+            field_dict["other"] = other
+        if start is not UNSET:
+            field_dict["start"] = start
+
+        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)
+
+        exclude_filters = cast(list[str], d.pop("excludeFilters", UNSET))
+
+        field = d.pop("field", UNSET)
+
+        gap = d.pop("gap", UNSET)
+
+        hardend = d.pop("hardend", UNSET)
+
+        include = cast(list[str], d.pop("include", UNSET))
+
+        label = d.pop("label", UNSET)
+
+        other = cast(list[str], d.pop("other", UNSET))
+
+        start = d.pop("start", UNSET)
+
+        request_range = cls(
+            end=end,
+            exclude_filters=exclude_filters,
+            field=field,
+            gap=gap,
+            hardend=hardend,
+            include=include,
+            label=label,
+            other=other,
+            start=start,
+        )
+
+        request_range.additional_properties = d
+        return request_range
+
+    @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_scope.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 ..models.request_scope_locations import RequestScopeLocations
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="RequestScope")
+
+
+@_attrs_define
+class RequestScope:
+    """Scope
+
+    Attributes:
+        locations (Union[Unset, RequestScopeLocations]): The locations to include in the query
+    """
+
+    locations: Union[Unset, RequestScopeLocations] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        locations: Union[Unset, str] = UNSET
+        if not isinstance(self.locations, Unset):
+            locations = self.locations.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if locations is not UNSET:
+            field_dict["locations"] = locations
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        _locations = d.pop("locations", UNSET)
+        locations: Union[Unset, RequestScopeLocations]
+        if isinstance(_locations, Unset):
+            locations = UNSET
+        else:
+            locations = RequestScopeLocations(_locations)
+
+        request_scope = cls(
+            locations=locations,
+        )
+
+        request_scope.additional_properties = d
+        return request_scope
+
+    @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_scope_locations.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class RequestScopeLocations(str, Enum):
+    DELETED_NODES = "deleted-nodes"
+    NODES = "nodes"
+    VERSIONS = "versions"
+
+    def __str__(self) -> str:
+        return str(self.value)

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

@@ -0,0 +1,87 @@
+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_sort_definition_item_type import RequestSortDefinitionItemType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="RequestSortDefinitionItem")
+
+
+@_attrs_define
+class RequestSortDefinitionItem:
+    """
+    Attributes:
+        ascending (Union[Unset, bool]): The sort order. (The ordering of nulls is determined by the SOLR configuration)
+            Default: False.
+        field (Union[Unset, str]): The name of the field
+        type_ (Union[Unset, RequestSortDefinitionItemType]): How to order - using a field, when position of the document
+            in the index, score/relevence. Default: RequestSortDefinitionItemType.FIELD.
+    """
+
+    ascending: Union[Unset, bool] = False
+    field: Union[Unset, str] = UNSET
+    type_: Union[Unset, RequestSortDefinitionItemType] = RequestSortDefinitionItemType.FIELD
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        ascending = self.ascending
+
+        field = self.field
+
+        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 ascending is not UNSET:
+            field_dict["ascending"] = ascending
+        if field is not UNSET:
+            field_dict["field"] = field
+        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)
+        ascending = d.pop("ascending", UNSET)
+
+        field = d.pop("field", UNSET)
+
+        _type_ = d.pop("type", UNSET)
+        type_: Union[Unset, RequestSortDefinitionItemType]
+        if isinstance(_type_, Unset):
+            type_ = UNSET
+        else:
+            type_ = RequestSortDefinitionItemType(_type_)
+
+        request_sort_definition_item = cls(
+            ascending=ascending,
+            field=field,
+            type_=type_,
+        )
+
+        request_sort_definition_item.additional_properties = d
+        return request_sort_definition_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_sort_definition_item_type.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class RequestSortDefinitionItemType(str, Enum):
+    DOCUMENT = "DOCUMENT"
+    FIELD = "FIELD"
+    SCORE = "SCORE"
+
+    def __str__(self) -> str:
+        return str(self.value)

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

@@ -0,0 +1,61 @@
+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="RequestSpellcheck")
+
+
+@_attrs_define
+class RequestSpellcheck:
+    """Request that spellcheck fragments to be added to result set rows
+    The properties reflect SOLR spellcheck parameters.
+
+        Attributes:
+            query (Union[Unset, str]):
+    """
+
+    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
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        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)
+        query = d.pop("query", UNSET)
+
+        request_spellcheck = cls(
+            query=query,
+        )
+
+        request_spellcheck.additional_properties = d
+        return request_spellcheck
+
+    @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_stats.py

@@ -0,0 +1,202 @@
+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="RequestStats")
+
+
+@_attrs_define
+class RequestStats:
+    """A list of stats request.
+
+    Attributes:
+        cardinality (Union[Unset, bool]): A statistical approximation of the number of distinct values Default: False.
+        cardinality_accuracy (Union[Unset, float]): Number between 0.0 and 1.0 indicating how aggressively the algorithm
+            should try to be accurate. Used with boolean cardinality flag. Default: 0.3.
+        count_distinct (Union[Unset, bool]): The number of distinct values  (This can be very expensive to calculate)
+            Default: False.
+        count_values (Union[Unset, bool]): The number which have a value for this field Default: True.
+        distinct_values (Union[Unset, bool]): The set of all distinct values for the field (This can be very expensive
+            to calculate) Default: False.
+        exclude_filters (Union[Unset, list[str]]): A list of filters to exclude
+        field (Union[Unset, str]): The stats field
+        label (Union[Unset, str]): A label to include for reference the stats field
+        max_ (Union[Unset, bool]): The maximum value of the field Default: True.
+        mean (Union[Unset, bool]): The average Default: True.
+        min_ (Union[Unset, bool]): The minimum value of the field Default: True.
+        missing (Union[Unset, bool]): The number which do not have a value for this field Default: True.
+        percentiles (Union[Unset, list[float]]): A list of percentile values, e.g. "1,99,99.9"
+        stddev (Union[Unset, bool]): Standard deviation Default: True.
+        sum_ (Union[Unset, bool]): The sum of all values of the field Default: True.
+        sum_of_squares (Union[Unset, bool]): Sum of all values squared Default: True.
+    """
+
+    cardinality: Union[Unset, bool] = False
+    cardinality_accuracy: Union[Unset, float] = 0.3
+    count_distinct: Union[Unset, bool] = False
+    count_values: Union[Unset, bool] = True
+    distinct_values: Union[Unset, bool] = False
+    exclude_filters: Union[Unset, list[str]] = UNSET
+    field: Union[Unset, str] = UNSET
+    label: Union[Unset, str] = UNSET
+    max_: Union[Unset, bool] = True
+    mean: Union[Unset, bool] = True
+    min_: Union[Unset, bool] = True
+    missing: Union[Unset, bool] = True
+    percentiles: Union[Unset, list[float]] = UNSET
+    stddev: Union[Unset, bool] = True
+    sum_: Union[Unset, bool] = True
+    sum_of_squares: Union[Unset, bool] = True
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        cardinality = self.cardinality
+
+        cardinality_accuracy = self.cardinality_accuracy
+
+        count_distinct = self.count_distinct
+
+        count_values = self.count_values
+
+        distinct_values = self.distinct_values
+
+        exclude_filters: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.exclude_filters, Unset):
+            exclude_filters = self.exclude_filters
+
+        field = self.field
+
+        label = self.label
+
+        max_ = self.max_
+
+        mean = self.mean
+
+        min_ = self.min_
+
+        missing = self.missing
+
+        percentiles: Union[Unset, list[float]] = UNSET
+        if not isinstance(self.percentiles, Unset):
+            percentiles = self.percentiles
+
+        stddev = self.stddev
+
+        sum_ = self.sum_
+
+        sum_of_squares = self.sum_of_squares
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if cardinality is not UNSET:
+            field_dict["cardinality"] = cardinality
+        if cardinality_accuracy is not UNSET:
+            field_dict["cardinalityAccuracy"] = cardinality_accuracy
+        if count_distinct is not UNSET:
+            field_dict["countDistinct"] = count_distinct
+        if count_values is not UNSET:
+            field_dict["countValues"] = count_values
+        if distinct_values is not UNSET:
+            field_dict["distinctValues"] = distinct_values
+        if exclude_filters is not UNSET:
+            field_dict["excludeFilters"] = exclude_filters
+        if field is not UNSET:
+            field_dict["field"] = field
+        if label is not UNSET:
+            field_dict["label"] = label
+        if max_ is not UNSET:
+            field_dict["max"] = max_
+        if mean is not UNSET:
+            field_dict["mean"] = mean
+        if min_ is not UNSET:
+            field_dict["min"] = min_
+        if missing is not UNSET:
+            field_dict["missing"] = missing
+        if percentiles is not UNSET:
+            field_dict["percentiles"] = percentiles
+        if stddev is not UNSET:
+            field_dict["stddev"] = stddev
+        if sum_ is not UNSET:
+            field_dict["sum"] = sum_
+        if sum_of_squares is not UNSET:
+            field_dict["sumOfSquares"] = sum_of_squares
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        cardinality = d.pop("cardinality", UNSET)
+
+        cardinality_accuracy = d.pop("cardinalityAccuracy", UNSET)
+
+        count_distinct = d.pop("countDistinct", UNSET)
+
+        count_values = d.pop("countValues", UNSET)
+
+        distinct_values = d.pop("distinctValues", UNSET)
+
+        exclude_filters = cast(list[str], d.pop("excludeFilters", UNSET))
+
+        field = d.pop("field", UNSET)
+
+        label = d.pop("label", UNSET)
+
+        max_ = d.pop("max", UNSET)
+
+        mean = d.pop("mean", UNSET)
+
+        min_ = d.pop("min", UNSET)
+
+        missing = d.pop("missing", UNSET)
+
+        percentiles = cast(list[float], d.pop("percentiles", UNSET))
+
+        stddev = d.pop("stddev", UNSET)
+
+        sum_ = d.pop("sum", UNSET)
+
+        sum_of_squares = d.pop("sumOfSquares", UNSET)
+
+        request_stats = cls(
+            cardinality=cardinality,
+            cardinality_accuracy=cardinality_accuracy,
+            count_distinct=count_distinct,
+            count_values=count_values,
+            distinct_values=distinct_values,
+            exclude_filters=exclude_filters,
+            field=field,
+            label=label,
+            max_=max_,
+            mean=mean,
+            min_=min_,
+            missing=missing,
+            percentiles=percentiles,
+            stddev=stddev,
+            sum_=sum_,
+            sum_of_squares=sum_of_squares,
+        )
+
+        request_stats.additional_properties = d
+        return request_stats
+
+    @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_templates_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="RequestTemplatesItem")
+
+
+@_attrs_define
+class RequestTemplatesItem:
+    """
+    Attributes:
+        name (Union[Unset, str]): The template name
+        template (Union[Unset, str]): The template
+    """
+
+    name: Union[Unset, str] = UNSET
+    template: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        template = self.template
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+        if template is not UNSET:
+            field_dict["template"] = template
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name", UNSET)
+
+        template = d.pop("template", UNSET)
+
+        request_templates_item = cls(
+            name=name,
+            template=template,
+        )
+
+        request_templates_item.additional_properties = d
+        return request_templates_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