cirro_api_client.v1.models

 5class AccessType(str, Enum):
 6    DATASET_UPLOAD = "DATASET_UPLOAD"
 7    PROJECT_DOWNLOAD = "PROJECT_DOWNLOAD"
 8    REFERENCE_UPLOAD = "REFERENCE_UPLOAD"
 9    SAMPLESHEET_UPLOAD = "SAMPLESHEET_UPLOAD"
10
11    def __str__(self) -> str:
12        return str(self.value)

14@_attrs_define
15class AllowedDataType:
16    """
17    Attributes:
18        description (str):
19        error_msg (str):
20        allowed_patterns (List['FileNamePattern']):
21    """
22
23    description: str
24    error_msg: str
25    allowed_patterns: List["FileNamePattern"]
26    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
27
28    def to_dict(self) -> Dict[str, Any]:
29        description = self.description
30
31        error_msg = self.error_msg
32
33        allowed_patterns = []
34        for allowed_patterns_item_data in self.allowed_patterns:
35            allowed_patterns_item = allowed_patterns_item_data.to_dict()
36            allowed_patterns.append(allowed_patterns_item)
37
38        field_dict: Dict[str, Any] = {}
39        field_dict.update(self.additional_properties)
40        field_dict.update(
41            {
42                "description": description,
43                "errorMsg": error_msg,
44                "allowedPatterns": allowed_patterns,
45            }
46        )
47
48        return field_dict
49
50    @classmethod
51    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
52        from ..models.file_name_pattern import FileNamePattern
53
54        d = src_dict.copy()
55        description = d.pop("description")
56
57        error_msg = d.pop("errorMsg")
58
59        allowed_patterns = []
60        _allowed_patterns = d.pop("allowedPatterns")
61        for allowed_patterns_item_data in _allowed_patterns:
62            allowed_patterns_item = FileNamePattern.from_dict(allowed_patterns_item_data)
63
64            allowed_patterns.append(allowed_patterns_item)
65
66        allowed_data_type = cls(
67            description=description,
68            error_msg=error_msg,
69            allowed_patterns=allowed_patterns,
70        )
71
72        allowed_data_type.additional_properties = d
73        return allowed_data_type
74
75    @property
76    def additional_keys(self) -> List[str]:
77        return list(self.additional_properties.keys())

 19@_attrs_define
 20class AuditEvent:
 21    """
 22    Attributes:
 23        id (Union[Unset, str]): The unique identifier for the audit event
 24        event_type (Union[Unset, str]): The type of event Example: CREATE.
 25        project_id (Union[Unset, str]): The project ID associated with the event (if applicable)
 26        entity_id (Union[Unset, str]): The entity ID associated with the event
 27        entity_type (Union[Unset, str]): The entity type associated with the event Example: ProjectRecord.
 28        event_detail (Union['AuditEventEventDetailType0', None, Unset]): The details of the event, such as the request
 29            details sent from the client
 30        changes (Union['AuditEventChangesType0', None, Unset]): The changes made to the entity (if applicable) Example:
 31            {'.settings.retentionPolicyDays': '1 -> 2'}.
 32        username (Union[Unset, str]): The username of the user who performed the action Example: admin@cirro.bio.
 33        ip_address (Union[Unset, str]): The IP address of the user who performed the action Example: 0.0.0.0.
 34        created_at (Union[Unset, datetime.datetime]): The date and time the event was created
 35    """
 36
 37    id: Union[Unset, str] = UNSET
 38    event_type: Union[Unset, str] = UNSET
 39    project_id: Union[Unset, str] = UNSET
 40    entity_id: Union[Unset, str] = UNSET
 41    entity_type: Union[Unset, str] = UNSET
 42    event_detail: Union["AuditEventEventDetailType0", None, Unset] = UNSET
 43    changes: Union["AuditEventChangesType0", None, Unset] = UNSET
 44    username: Union[Unset, str] = UNSET
 45    ip_address: Union[Unset, str] = UNSET
 46    created_at: Union[Unset, datetime.datetime] = UNSET
 47    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
 48
 49    def to_dict(self) -> Dict[str, Any]:
 50        from ..models.audit_event_changes_type_0 import AuditEventChangesType0
 51        from ..models.audit_event_event_detail_type_0 import AuditEventEventDetailType0
 52
 53        id = self.id
 54
 55        event_type = self.event_type
 56
 57        project_id = self.project_id
 58
 59        entity_id = self.entity_id
 60
 61        entity_type = self.entity_type
 62
 63        event_detail: Union[Dict[str, Any], None, Unset]
 64        if isinstance(self.event_detail, Unset):
 65            event_detail = UNSET
 66        elif isinstance(self.event_detail, AuditEventEventDetailType0):
 67            event_detail = self.event_detail.to_dict()
 68        else:
 69            event_detail = self.event_detail
 70
 71        changes: Union[Dict[str, Any], None, Unset]
 72        if isinstance(self.changes, Unset):
 73            changes = UNSET
 74        elif isinstance(self.changes, AuditEventChangesType0):
 75            changes = self.changes.to_dict()
 76        else:
 77            changes = self.changes
 78
 79        username = self.username
 80
 81        ip_address = self.ip_address
 82
 83        created_at: Union[Unset, str] = UNSET
 84        if not isinstance(self.created_at, Unset):
 85            created_at = self.created_at.isoformat()
 86
 87        field_dict: Dict[str, Any] = {}
 88        field_dict.update(self.additional_properties)
 89        field_dict.update({})
 90        if id is not UNSET:
 91            field_dict["id"] = id
 92        if event_type is not UNSET:
 93            field_dict["eventType"] = event_type
 94        if project_id is not UNSET:
 95            field_dict["projectId"] = project_id
 96        if entity_id is not UNSET:
 97            field_dict["entityId"] = entity_id
 98        if entity_type is not UNSET:
 99            field_dict["entityType"] = entity_type
100        if event_detail is not UNSET:
101            field_dict["eventDetail"] = event_detail
102        if changes is not UNSET:
103            field_dict["changes"] = changes
104        if username is not UNSET:
105            field_dict["username"] = username
106        if ip_address is not UNSET:
107            field_dict["ipAddress"] = ip_address
108        if created_at is not UNSET:
109            field_dict["createdAt"] = created_at
110
111        return field_dict
112
113    @classmethod
114    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
115        from ..models.audit_event_changes_type_0 import AuditEventChangesType0
116        from ..models.audit_event_event_detail_type_0 import AuditEventEventDetailType0
117
118        d = src_dict.copy()
119        id = d.pop("id", UNSET)
120
121        event_type = d.pop("eventType", UNSET)
122
123        project_id = d.pop("projectId", UNSET)
124
125        entity_id = d.pop("entityId", UNSET)
126
127        entity_type = d.pop("entityType", UNSET)
128
129        def _parse_event_detail(data: object) -> Union["AuditEventEventDetailType0", None, Unset]:
130            if data is None:
131                return data
132            if isinstance(data, Unset):
133                return data
134            try:
135                if not isinstance(data, dict):
136                    raise TypeError()
137                event_detail_type_0 = AuditEventEventDetailType0.from_dict(data)
138
139                return event_detail_type_0
140            except:  # noqa: E722
141                pass
142            return cast(Union["AuditEventEventDetailType0", None, Unset], data)
143
144        event_detail = _parse_event_detail(d.pop("eventDetail", UNSET))
145
146        def _parse_changes(data: object) -> Union["AuditEventChangesType0", None, Unset]:
147            if data is None:
148                return data
149            if isinstance(data, Unset):
150                return data
151            try:
152                if not isinstance(data, dict):
153                    raise TypeError()
154                changes_type_0 = AuditEventChangesType0.from_dict(data)
155
156                return changes_type_0
157            except:  # noqa: E722
158                pass
159            return cast(Union["AuditEventChangesType0", None, Unset], data)
160
161        changes = _parse_changes(d.pop("changes", UNSET))
162
163        username = d.pop("username", UNSET)
164
165        ip_address = d.pop("ipAddress", UNSET)
166
167        _created_at = d.pop("createdAt", UNSET)
168        created_at: Union[Unset, datetime.datetime]
169        if isinstance(_created_at, Unset):
170            created_at = UNSET
171        else:
172            created_at = isoparse(_created_at)
173
174        audit_event = cls(
175            id=id,
176            event_type=event_type,
177            project_id=project_id,
178            entity_id=entity_id,
179            entity_type=entity_type,
180            event_detail=event_detail,
181            changes=changes,
182            username=username,
183            ip_address=ip_address,
184            created_at=created_at,
185        )
186
187        audit_event.additional_properties = d
188        return audit_event
189
190    @property
191    def additional_keys(self) -> List[str]:
192        return list(self.additional_properties.keys())

10@_attrs_define
11class AuditEventChangesType0:
12    """The changes made to the entity (if applicable)
13
14    Example:
15        {'.settings.retentionPolicyDays': '1 -> 2'}
16
17    """
18
19    additional_properties: Dict[str, str] = _attrs_field(init=False, factory=dict)
20
21    def to_dict(self) -> Dict[str, Any]:
22        field_dict: Dict[str, Any] = {}
23        field_dict.update(self.additional_properties)
24        field_dict.update({})
25
26        return field_dict
27
28    @classmethod
29    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
30        d = src_dict.copy()
31        audit_event_changes_type_0 = cls()
32
33        audit_event_changes_type_0.additional_properties = d
34        return audit_event_changes_type_0
35
36    @property
37    def additional_keys(self) -> List[str]:
38        return list(self.additional_properties.keys())

10@_attrs_define
11class AuditEventEventDetailType0:
12    """The details of the event, such as the request details sent from the client"""
13
14    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
15
16    def to_dict(self) -> Dict[str, Any]:
17        field_dict: Dict[str, Any] = {}
18        field_dict.update(self.additional_properties)
19        field_dict.update({})
20
21        return field_dict
22
23    @classmethod
24    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
25        d = src_dict.copy()
26        audit_event_event_detail_type_0 = cls()
27
28        audit_event_event_detail_type_0.additional_properties = d
29        return audit_event_event_detail_type_0
30
31    @property
32    def additional_keys(self) -> List[str]:
33        return list(self.additional_properties.keys())

10@_attrs_define
11class AuthInfo:
12    """
13    Attributes:
14        user_pool_id (str):
15        sdk_app_id (str):
16        ui_app_id (str):
17        endpoint (str):
18    """
19
20    user_pool_id: str
21    sdk_app_id: str
22    ui_app_id: str
23    endpoint: str
24    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
25
26    def to_dict(self) -> Dict[str, Any]:
27        user_pool_id = self.user_pool_id
28
29        sdk_app_id = self.sdk_app_id
30
31        ui_app_id = self.ui_app_id
32
33        endpoint = self.endpoint
34
35        field_dict: Dict[str, Any] = {}
36        field_dict.update(self.additional_properties)
37        field_dict.update(
38            {
39                "userPoolId": user_pool_id,
40                "sdkAppId": sdk_app_id,
41                "uiAppId": ui_app_id,
42                "endpoint": endpoint,
43            }
44        )
45
46        return field_dict
47
48    @classmethod
49    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
50        d = src_dict.copy()
51        user_pool_id = d.pop("userPoolId")
52
53        sdk_app_id = d.pop("sdkAppId")
54
55        ui_app_id = d.pop("uiAppId")
56
57        endpoint = d.pop("endpoint")
58
59        auth_info = cls(
60            user_pool_id=user_pool_id,
61            sdk_app_id=sdk_app_id,
62            ui_app_id=ui_app_id,
63            endpoint=endpoint,
64        )
65
66        auth_info.additional_properties = d
67        return auth_info
68
69    @property
70    def additional_keys(self) -> List[str]:
71        return list(self.additional_properties.keys())

14@_attrs_define
15class AWSCredentials:
16    """
17    Attributes:
18        access_key_id (str):
19        secret_access_key (str):
20        session_token (str):
21        expiration (datetime.datetime):
22        region (Union[Unset, str]): Region of requested resource (i.e., S3 Bucket)
23    """
24
25    access_key_id: str
26    secret_access_key: str
27    session_token: str
28    expiration: datetime.datetime
29    region: Union[Unset, str] = UNSET
30    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
31
32    def to_dict(self) -> Dict[str, Any]:
33        access_key_id = self.access_key_id
34
35        secret_access_key = self.secret_access_key
36
37        session_token = self.session_token
38
39        expiration = self.expiration.isoformat()
40
41        region = self.region
42
43        field_dict: Dict[str, Any] = {}
44        field_dict.update(self.additional_properties)
45        field_dict.update(
46            {
47                "accessKeyId": access_key_id,
48                "secretAccessKey": secret_access_key,
49                "sessionToken": session_token,
50                "expiration": expiration,
51            }
52        )
53        if region is not UNSET:
54            field_dict["region"] = region
55
56        return field_dict
57
58    @classmethod
59    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
60        d = src_dict.copy()
61        access_key_id = d.pop("accessKeyId")
62
63        secret_access_key = d.pop("secretAccessKey")
64
65        session_token = d.pop("sessionToken")
66
67        expiration = isoparse(d.pop("expiration"))
68
69        region = d.pop("region", UNSET)
70
71        aws_credentials = cls(
72            access_key_id=access_key_id,
73            secret_access_key=secret_access_key,
74            session_token=session_token,
75            expiration=expiration,
76            region=region,
77        )
78
79        aws_credentials.additional_properties = d
80        return aws_credentials
81
82    @property
83    def additional_keys(self) -> List[str]:
84        return list(self.additional_properties.keys())