sqlx

python-client/windmill-api/windmill_api/models/user.py

@@ -0,0 +1,185 @@
+from typing import Any, Dict, Type, TypeVar, Tuple, Optional, BinaryIO, TextIO, TYPE_CHECKING
+
+from typing import List
+
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from typing import Union
+from typing import cast
+from typing import cast, List
+from typing import Dict
+import datetime
+from dateutil.parser import isoparse
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.user_usage import UserUsage
+
+
+
+
+
+T = TypeVar("T", bound="User")
+
+
+@_attrs_define
+class User:
+    """ 
+        Attributes:
+            email (str):
+            username (str):
+            is_admin (bool):
+            is_super_admin (bool):
+            created_at (datetime.datetime):
+            operator (bool):
+            disabled (bool):
+            folders (List[str]):
+            folders_owners (List[str]):
+            groups (Union[Unset, List[str]]):
+            usage (Union[Unset, UserUsage]):
+     """
+
+    email: str
+    username: str
+    is_admin: bool
+    is_super_admin: bool
+    created_at: datetime.datetime
+    operator: bool
+    disabled: bool
+    folders: List[str]
+    folders_owners: List[str]
+    groups: Union[Unset, List[str]] = UNSET
+    usage: Union[Unset, 'UserUsage'] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        from ..models.user_usage import UserUsage
+        email = self.email
+        username = self.username
+        is_admin = self.is_admin
+        is_super_admin = self.is_super_admin
+        created_at = self.created_at.isoformat()
+
+        operator = self.operator
+        disabled = self.disabled
+        folders = self.folders
+
+
+
+
+        folders_owners = self.folders_owners
+
+
+
+
+        groups: Union[Unset, List[str]] = UNSET
+        if not isinstance(self.groups, Unset):
+            groups = self.groups
+
+
+
+
+        usage: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.usage, Unset):
+            usage = self.usage.to_dict()
+
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "email": email,
+            "username": username,
+            "is_admin": is_admin,
+            "is_super_admin": is_super_admin,
+            "created_at": created_at,
+            "operator": operator,
+            "disabled": disabled,
+            "folders": folders,
+            "folders_owners": folders_owners,
+        })
+        if groups is not UNSET:
+            field_dict["groups"] = groups
+        if usage is not UNSET:
+            field_dict["usage"] = usage
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.user_usage import UserUsage
+        d = src_dict.copy()
+        email = d.pop("email")
+
+        username = d.pop("username")
+
+        is_admin = d.pop("is_admin")
+
+        is_super_admin = d.pop("is_super_admin")
+
+        created_at = isoparse(d.pop("created_at"))
+
+
+
+
+        operator = d.pop("operator")
+
+        disabled = d.pop("disabled")
+
+        folders = cast(List[str], d.pop("folders"))
+
+
+        folders_owners = cast(List[str], d.pop("folders_owners"))
+
+
+        groups = cast(List[str], d.pop("groups", UNSET))
+
+
+        _usage = d.pop("usage", UNSET)
+        usage: Union[Unset, UserUsage]
+        if isinstance(_usage,  Unset):
+            usage = UNSET
+        else:
+            usage = UserUsage.from_dict(_usage)
+
+
+
+
+        user = cls(
+            email=email,
+            username=username,
+            is_admin=is_admin,
+            is_super_admin=is_super_admin,
+            created_at=created_at,
+            operator=operator,
+            disabled=disabled,
+            folders=folders,
+            folders_owners=folders_owners,
+            groups=groups,
+            usage=usage,
+        )
+
+        user.additional_properties = d
+        return user
+
+    @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