antfly-sdk 0.0.2.dev2__py3-none-any.whl

antfly/client_generated/models/create_user_request.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.create_user_request_metadata_type_0 import CreateUserRequestMetadataType0
+    from ..models.permission import Permission
+
+
+T = TypeVar("T", bound="CreateUserRequest")
+
+
+@_attrs_define
+class CreateUserRequest:
+    """
+    Attributes:
+        password (str):  Example: s3cr3tP@sswOrd.
+        username (str | Unset): Username for the new user. If provided in the path, this field can be omitted or must
+            match the path parameter. Example: johndoe.
+        initial_policies (list[Permission] | None | Unset): Optional list of initial permissions for the user.
+        metadata (CreateUserRequestMetadataType0 | None | Unset): Auth metadata available to stored row-filter policies.
+            Example: {'tenant_id': 'acme'}.
+    """
+
+    password: str
+    username: str | Unset = UNSET
+    initial_policies: list[Permission] | None | Unset = UNSET
+    metadata: CreateUserRequestMetadataType0 | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.create_user_request_metadata_type_0 import CreateUserRequestMetadataType0
+
+        password = self.password
+
+        username = self.username
+
+        initial_policies: list[dict[str, Any]] | None | Unset
+        if isinstance(self.initial_policies, Unset):
+            initial_policies = UNSET
+        elif isinstance(self.initial_policies, list):
+            initial_policies = []
+            for initial_policies_type_0_item_data in self.initial_policies:
+                initial_policies_type_0_item = initial_policies_type_0_item_data.to_dict()
+                initial_policies.append(initial_policies_type_0_item)
+
+        else:
+            initial_policies = self.initial_policies
+
+        metadata: dict[str, Any] | None | Unset
+        if isinstance(self.metadata, Unset):
+            metadata = UNSET
+        elif isinstance(self.metadata, CreateUserRequestMetadataType0):
+            metadata = self.metadata.to_dict()
+        else:
+            metadata = self.metadata
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "password": password,
+            }
+        )
+        if username is not UNSET:
+            field_dict["username"] = username
+        if initial_policies is not UNSET:
+            field_dict["initial_policies"] = initial_policies
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.create_user_request_metadata_type_0 import CreateUserRequestMetadataType0
+        from ..models.permission import Permission
+
+        d = dict(src_dict)
+        password = d.pop("password")
+
+        username = d.pop("username", UNSET)
+
+        def _parse_initial_policies(data: object) -> list[Permission] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                initial_policies_type_0 = []
+                _initial_policies_type_0 = data
+                for initial_policies_type_0_item_data in _initial_policies_type_0:
+                    initial_policies_type_0_item = Permission.from_dict(initial_policies_type_0_item_data)
+
+                    initial_policies_type_0.append(initial_policies_type_0_item)
+
+                return initial_policies_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[Permission] | None | Unset, data)
+
+        initial_policies = _parse_initial_policies(d.pop("initial_policies", UNSET))
+
+        def _parse_metadata(data: object) -> CreateUserRequestMetadataType0 | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                metadata_type_0 = CreateUserRequestMetadataType0.from_dict(data)
+
+                return metadata_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(CreateUserRequestMetadataType0 | None | Unset, data)
+
+        metadata = _parse_metadata(d.pop("metadata", UNSET))
+
+        create_user_request = cls(
+            password=password,
+            username=username,
+            initial_policies=initial_policies,
+            metadata=metadata,
+        )
+
+        create_user_request.additional_properties = d
+        return create_user_request
+
+    @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

antfly/client_generated/models/create_user_request_metadata_type_0.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="CreateUserRequestMetadataType0")
+
+
+@_attrs_define
+class CreateUserRequestMetadataType0:
+    """Auth metadata available to stored row-filter policies.
+
+    Example:
+        {'tenant_id': 'acme'}
+
+    """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        create_user_request_metadata_type_0 = cls()
+
+        create_user_request_metadata_type_0.additional_properties = d
+        return create_user_request_metadata_type_0
+
+    @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

antfly/client_generated/models/credentials.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="Credentials")
+
+
+@_attrs_define
+class Credentials:
+    """
+    Attributes:
+        endpoint (str | Unset): S3-compatible endpoint (e.g., 's3.amazonaws.com' or 'localhost:9000' for MinIO) Example:
+            s3.amazonaws.com.
+        use_ssl (bool | Unset): Enable SSL/TLS for S3 connections (default: true for AWS, false for local MinIO)
+            Default: True.
+        access_key_id (str | Unset): AWS access key ID. Supports keystore syntax for secret lookup. Falls back to
+            AWS_ACCESS_KEY_ID environment variable if not set. Example: your-access-key-id.
+        secret_access_key (str | Unset): AWS secret access key. Supports keystore syntax for secret lookup. Falls back
+            to AWS_SECRET_ACCESS_KEY environment variable if not set. Example: your-secret-access-key.
+        session_token (str | Unset): Optional AWS session token for temporary credentials. Supports keystore syntax for
+            secret lookup. Example: your-session-token.
+    """
+
+    endpoint: str | Unset = UNSET
+    use_ssl: bool | Unset = True
+    access_key_id: str | Unset = UNSET
+    secret_access_key: str | Unset = UNSET
+    session_token: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        endpoint = self.endpoint
+
+        use_ssl = self.use_ssl
+
+        access_key_id = self.access_key_id
+
+        secret_access_key = self.secret_access_key
+
+        session_token = self.session_token
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if endpoint is not UNSET:
+            field_dict["endpoint"] = endpoint
+        if use_ssl is not UNSET:
+            field_dict["use_ssl"] = use_ssl
+        if access_key_id is not UNSET:
+            field_dict["access_key_id"] = access_key_id
+        if secret_access_key is not UNSET:
+            field_dict["secret_access_key"] = secret_access_key
+        if session_token is not UNSET:
+            field_dict["session_token"] = session_token
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        endpoint = d.pop("endpoint", UNSET)
+
+        use_ssl = d.pop("use_ssl", UNSET)
+
+        access_key_id = d.pop("access_key_id", UNSET)
+
+        secret_access_key = d.pop("secret_access_key", UNSET)
+
+        session_token = d.pop("session_token", UNSET)
+
+        credentials = cls(
+            endpoint=endpoint,
+            use_ssl=use_ssl,
+            access_key_id=access_key_id,
+            secret_access_key=secret_access_key,
+            session_token=session_token,
+        )
+
+        credentials.additional_properties = d
+        return credentials
+
+    @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

antfly/client_generated/models/date_range_string_query.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="DateRangeStringQuery")
+
+
+@_attrs_define
+class DateRangeStringQuery:
+    """
+    Attributes:
+        start (datetime.datetime | Unset):
+        end (datetime.datetime | Unset):
+        inclusive_start (bool | None | Unset):
+        inclusive_end (bool | None | Unset):
+        field (str | Unset):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+        datetime_parser (str | Unset):
+    """
+
+    start: datetime.datetime | Unset = UNSET
+    end: datetime.datetime | Unset = UNSET
+    inclusive_start: bool | None | Unset = UNSET
+    inclusive_end: bool | None | Unset = UNSET
+    field: str | Unset = UNSET
+    boost: float | None | Unset = UNSET
+    datetime_parser: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        start: str | Unset = UNSET
+        if not isinstance(self.start, Unset):
+            start = self.start.isoformat()
+
+        end: str | Unset = UNSET
+        if not isinstance(self.end, Unset):
+            end = self.end.isoformat()
+
+        inclusive_start: bool | None | Unset
+        if isinstance(self.inclusive_start, Unset):
+            inclusive_start = UNSET
+        else:
+            inclusive_start = self.inclusive_start
+
+        inclusive_end: bool | None | Unset
+        if isinstance(self.inclusive_end, Unset):
+            inclusive_end = UNSET
+        else:
+            inclusive_end = self.inclusive_end
+
+        field = self.field
+
+        boost: float | None | Unset
+        if isinstance(self.boost, Unset):
+            boost = UNSET
+        else:
+            boost = self.boost
+
+        datetime_parser = self.datetime_parser
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if start is not UNSET:
+            field_dict["start"] = start
+        if end is not UNSET:
+            field_dict["end"] = end
+        if inclusive_start is not UNSET:
+            field_dict["inclusive_start"] = inclusive_start
+        if inclusive_end is not UNSET:
+            field_dict["inclusive_end"] = inclusive_end
+        if field is not UNSET:
+            field_dict["field"] = field
+        if boost is not UNSET:
+            field_dict["boost"] = boost
+        if datetime_parser is not UNSET:
+            field_dict["datetime_parser"] = datetime_parser
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        _start = d.pop("start", UNSET)
+        start: datetime.datetime | Unset
+        if isinstance(_start, Unset):
+            start = UNSET
+        else:
+            start = isoparse(_start)
+
+        _end = d.pop("end", UNSET)
+        end: datetime.datetime | Unset
+        if isinstance(_end, Unset):
+            end = UNSET
+        else:
+            end = isoparse(_end)
+
+        def _parse_inclusive_start(data: object) -> bool | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(bool | None | Unset, data)
+
+        inclusive_start = _parse_inclusive_start(d.pop("inclusive_start", UNSET))
+
+        def _parse_inclusive_end(data: object) -> bool | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(bool | None | Unset, data)
+
+        inclusive_end = _parse_inclusive_end(d.pop("inclusive_end", UNSET))
+
+        field = d.pop("field", UNSET)
+
+        def _parse_boost(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        boost = _parse_boost(d.pop("boost", UNSET))
+
+        datetime_parser = d.pop("datetime_parser", UNSET)
+
+        date_range_string_query = cls(
+            start=start,
+            end=end,
+            inclusive_start=inclusive_start,
+            inclusive_end=inclusive_end,
+            field=field,
+            boost=boost,
+            datetime_parser=datetime_parser,
+        )
+
+        date_range_string_query.additional_properties = d
+        return date_range_string_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