cirro_api_client.v1.models

17@_attrs_define
18class Agent:
19    """Details of the agent
20
21    Attributes:
22        status (AgentStatus): The status of the agent
23        id (Union[Unset, str]): The unique ID of the agent
24        name (Union[Unset, str]): The display name of the agent
25        tags (Union[Unset, AgentTags]): Tags associated with the agent
26    """
27
28    status: AgentStatus
29    id: Union[Unset, str] = UNSET
30    name: Union[Unset, str] = UNSET
31    tags: Union[Unset, "AgentTags"] = UNSET
32    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
33
34    def to_dict(self) -> Dict[str, Any]:
35        status = self.status.value
36
37        id = self.id
38
39        name = self.name
40
41        tags: Union[Unset, Dict[str, Any]] = UNSET
42        if not isinstance(self.tags, Unset):
43            tags = self.tags.to_dict()
44
45        field_dict: Dict[str, Any] = {}
46        field_dict.update(self.additional_properties)
47        field_dict.update(
48            {
49                "status": status,
50            }
51        )
52        if id is not UNSET:
53            field_dict["id"] = id
54        if name is not UNSET:
55            field_dict["name"] = name
56        if tags is not UNSET:
57            field_dict["tags"] = tags
58
59        return field_dict
60
61    @classmethod
62    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
63        from ..models.agent_tags import AgentTags
64
65        d = src_dict.copy()
66        status = AgentStatus(d.pop("status"))
67
68        id = d.pop("id", UNSET)
69
70        name = d.pop("name", UNSET)
71
72        _tags = d.pop("tags", UNSET)
73        tags: Union[Unset, AgentTags]
74        if isinstance(_tags, Unset):
75            tags = UNSET
76        else:
77            tags = AgentTags.from_dict(_tags)
78
79        agent = cls(
80            status=status,
81            id=id,
82            name=name,
83            tags=tags,
84        )
85
86        agent.additional_properties = d
87        return agent
88
89    @property
90    def additional_keys(self) -> List[str]:
91        return list(self.additional_properties.keys())

 21@_attrs_define
 22class AgentDetail:
 23    """
 24    Attributes:
 25        id (str):
 26        name (str):
 27        agent_role_arn (str):
 28        status (AgentStatus): The status of the agent
 29        created_by (str):
 30        created_at (datetime.datetime):
 31        updated_at (datetime.datetime):
 32        registration (Union['AgentRegistration', None, Unset]):
 33        tags (Union['AgentDetailTags', None, Unset]):
 34        environment_configuration (Union['AgentDetailEnvironmentConfiguration', None, Unset]):
 35    """
 36
 37    id: str
 38    name: str
 39    agent_role_arn: str
 40    status: AgentStatus
 41    created_by: str
 42    created_at: datetime.datetime
 43    updated_at: datetime.datetime
 44    registration: Union["AgentRegistration", None, Unset] = UNSET
 45    tags: Union["AgentDetailTags", None, Unset] = UNSET
 46    environment_configuration: Union["AgentDetailEnvironmentConfiguration", None, Unset] = 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.agent_detail_environment_configuration import AgentDetailEnvironmentConfiguration
 51        from ..models.agent_detail_tags import AgentDetailTags
 52        from ..models.agent_registration import AgentRegistration
 53
 54        id = self.id
 55
 56        name = self.name
 57
 58        agent_role_arn = self.agent_role_arn
 59
 60        status = self.status.value
 61
 62        created_by = self.created_by
 63
 64        created_at = self.created_at.isoformat()
 65
 66        updated_at = self.updated_at.isoformat()
 67
 68        registration: Union[Dict[str, Any], None, Unset]
 69        if isinstance(self.registration, Unset):
 70            registration = UNSET
 71        elif isinstance(self.registration, AgentRegistration):
 72            registration = self.registration.to_dict()
 73        else:
 74            registration = self.registration
 75
 76        tags: Union[Dict[str, Any], None, Unset]
 77        if isinstance(self.tags, Unset):
 78            tags = UNSET
 79        elif isinstance(self.tags, AgentDetailTags):
 80            tags = self.tags.to_dict()
 81        else:
 82            tags = self.tags
 83
 84        environment_configuration: Union[Dict[str, Any], None, Unset]
 85        if isinstance(self.environment_configuration, Unset):
 86            environment_configuration = UNSET
 87        elif isinstance(self.environment_configuration, AgentDetailEnvironmentConfiguration):
 88            environment_configuration = self.environment_configuration.to_dict()
 89        else:
 90            environment_configuration = self.environment_configuration
 91
 92        field_dict: Dict[str, Any] = {}
 93        field_dict.update(self.additional_properties)
 94        field_dict.update(
 95            {
 96                "id": id,
 97                "name": name,
 98                "agentRoleArn": agent_role_arn,
 99                "status": status,
100                "createdBy": created_by,
101                "createdAt": created_at,
102                "updatedAt": updated_at,
103            }
104        )
105        if registration is not UNSET:
106            field_dict["registration"] = registration
107        if tags is not UNSET:
108            field_dict["tags"] = tags
109        if environment_configuration is not UNSET:
110            field_dict["environmentConfiguration"] = environment_configuration
111
112        return field_dict
113
114    @classmethod
115    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
116        from ..models.agent_detail_environment_configuration import AgentDetailEnvironmentConfiguration
117        from ..models.agent_detail_tags import AgentDetailTags
118        from ..models.agent_registration import AgentRegistration
119
120        d = src_dict.copy()
121        id = d.pop("id")
122
123        name = d.pop("name")
124
125        agent_role_arn = d.pop("agentRoleArn")
126
127        status = AgentStatus(d.pop("status"))
128
129        created_by = d.pop("createdBy")
130
131        created_at = isoparse(d.pop("createdAt"))
132
133        updated_at = isoparse(d.pop("updatedAt"))
134
135        def _parse_registration(data: object) -> Union["AgentRegistration", None, Unset]:
136            if data is None:
137                return data
138            if isinstance(data, Unset):
139                return data
140            try:
141                if not isinstance(data, dict):
142                    raise TypeError()
143                registration_type_1 = AgentRegistration.from_dict(data)
144
145                return registration_type_1
146            except:  # noqa: E722
147                pass
148            return cast(Union["AgentRegistration", None, Unset], data)
149
150        registration = _parse_registration(d.pop("registration", UNSET))
151
152        def _parse_tags(data: object) -> Union["AgentDetailTags", None, Unset]:
153            if data is None:
154                return data
155            if isinstance(data, Unset):
156                return data
157            try:
158                if not isinstance(data, dict):
159                    raise TypeError()
160                tags_type_0 = AgentDetailTags.from_dict(data)
161
162                return tags_type_0
163            except:  # noqa: E722
164                pass
165            return cast(Union["AgentDetailTags", None, Unset], data)
166
167        tags = _parse_tags(d.pop("tags", UNSET))
168
169        def _parse_environment_configuration(data: object) -> Union["AgentDetailEnvironmentConfiguration", None, Unset]:
170            if data is None:
171                return data
172            if isinstance(data, Unset):
173                return data
174            try:
175                if not isinstance(data, dict):
176                    raise TypeError()
177                environment_configuration_type_0 = AgentDetailEnvironmentConfiguration.from_dict(data)
178
179                return environment_configuration_type_0
180            except:  # noqa: E722
181                pass
182            return cast(Union["AgentDetailEnvironmentConfiguration", None, Unset], data)
183
184        environment_configuration = _parse_environment_configuration(d.pop("environmentConfiguration", UNSET))
185
186        agent_detail = cls(
187            id=id,
188            name=name,
189            agent_role_arn=agent_role_arn,
190            status=status,
191            created_by=created_by,
192            created_at=created_at,
193            updated_at=updated_at,
194            registration=registration,
195            tags=tags,
196            environment_configuration=environment_configuration,
197        )
198
199        agent_detail.additional_properties = d
200        return agent_detail
201
202    @property
203    def additional_keys(self) -> List[str]:
204        return list(self.additional_properties.keys())

10@_attrs_define
11class AgentDetailEnvironmentConfiguration:
12    """ """
13
14    additional_properties: Dict[str, str] = _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        agent_detail_environment_configuration = cls()
27
28        agent_detail_environment_configuration.additional_properties = d
29        return agent_detail_environment_configuration
30
31    @property
32    def additional_keys(self) -> List[str]:
33        return list(self.additional_properties.keys())

10@_attrs_define
11class AgentDetailTags:
12    """ """
13
14    additional_properties: Dict[str, str] = _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        agent_detail_tags = cls()
27
28        agent_detail_tags.additional_properties = d
29        return agent_detail_tags
30
31    @property
32    def additional_keys(self) -> List[str]:
33        return list(self.additional_properties.keys())

 18@_attrs_define
 19class AgentInput:
 20    """
 21    Attributes:
 22        name (str): The display name of the agent
 23        agent_role_arn (str): Arn of the AWS IAM role or user that the agent will use (JSONSchema format)
 24        id (Union[None, Unset, str]): The unique ID of the agent (required on create)
 25        configuration_options_schema (Union['AgentInputConfigurationOptionsSchema', None, Unset]): The configuration
 26            options available for the agent
 27        environment_configuration (Union['AgentInputEnvironmentConfiguration', None, Unset]): The environment
 28            configuration for the agent Example: {'PARTITION': 'restart'}.
 29        tags (Union['AgentInputTags', None, Unset]): The tags associated with the agent displayed to the user Example:
 30            {'Support Email': 'it@company.com'}.
 31    """
 32
 33    name: str
 34    agent_role_arn: str
 35    id: Union[None, Unset, str] = UNSET
 36    configuration_options_schema: Union["AgentInputConfigurationOptionsSchema", None, Unset] = UNSET
 37    environment_configuration: Union["AgentInputEnvironmentConfiguration", None, Unset] = UNSET
 38    tags: Union["AgentInputTags", None, Unset] = UNSET
 39    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
 40
 41    def to_dict(self) -> Dict[str, Any]:
 42        from ..models.agent_input_configuration_options_schema import AgentInputConfigurationOptionsSchema
 43        from ..models.agent_input_environment_configuration import AgentInputEnvironmentConfiguration
 44        from ..models.agent_input_tags import AgentInputTags
 45
 46        name = self.name
 47
 48        agent_role_arn = self.agent_role_arn
 49
 50        id: Union[None, Unset, str]
 51        if isinstance(self.id, Unset):
 52            id = UNSET
 53        else:
 54            id = self.id
 55
 56        configuration_options_schema: Union[Dict[str, Any], None, Unset]
 57        if isinstance(self.configuration_options_schema, Unset):
 58            configuration_options_schema = UNSET
 59        elif isinstance(self.configuration_options_schema, AgentInputConfigurationOptionsSchema):
 60            configuration_options_schema = self.configuration_options_schema.to_dict()
 61        else:
 62            configuration_options_schema = self.configuration_options_schema
 63
 64        environment_configuration: Union[Dict[str, Any], None, Unset]
 65        if isinstance(self.environment_configuration, Unset):
 66            environment_configuration = UNSET
 67        elif isinstance(self.environment_configuration, AgentInputEnvironmentConfiguration):
 68            environment_configuration = self.environment_configuration.to_dict()
 69        else:
 70            environment_configuration = self.environment_configuration
 71
 72        tags: Union[Dict[str, Any], None, Unset]
 73        if isinstance(self.tags, Unset):
 74            tags = UNSET
 75        elif isinstance(self.tags, AgentInputTags):
 76            tags = self.tags.to_dict()
 77        else:
 78            tags = self.tags
 79
 80        field_dict: Dict[str, Any] = {}
 81        field_dict.update(self.additional_properties)
 82        field_dict.update(
 83            {
 84                "name": name,
 85                "agentRoleArn": agent_role_arn,
 86            }
 87        )
 88        if id is not UNSET:
 89            field_dict["id"] = id
 90        if configuration_options_schema is not UNSET:
 91            field_dict["configurationOptionsSchema"] = configuration_options_schema
 92        if environment_configuration is not UNSET:
 93            field_dict["environmentConfiguration"] = environment_configuration
 94        if tags is not UNSET:
 95            field_dict["tags"] = tags
 96
 97        return field_dict
 98
 99    @classmethod
100    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
101        from ..models.agent_input_configuration_options_schema import AgentInputConfigurationOptionsSchema
102        from ..models.agent_input_environment_configuration import AgentInputEnvironmentConfiguration
103        from ..models.agent_input_tags import AgentInputTags
104
105        d = src_dict.copy()
106        name = d.pop("name")
107
108        agent_role_arn = d.pop("agentRoleArn")
109
110        def _parse_id(data: object) -> Union[None, Unset, str]:
111            if data is None:
112                return data
113            if isinstance(data, Unset):
114                return data
115            return cast(Union[None, Unset, str], data)
116
117        id = _parse_id(d.pop("id", UNSET))
118
119        def _parse_configuration_options_schema(
120            data: object,
121        ) -> Union["AgentInputConfigurationOptionsSchema", None, Unset]:
122            if data is None:
123                return data
124            if isinstance(data, Unset):
125                return data
126            try:
127                if not isinstance(data, dict):
128                    raise TypeError()
129                configuration_options_schema_type_0 = AgentInputConfigurationOptionsSchema.from_dict(data)
130
131                return configuration_options_schema_type_0
132            except:  # noqa: E722
133                pass
134            return cast(Union["AgentInputConfigurationOptionsSchema", None, Unset], data)
135
136        configuration_options_schema = _parse_configuration_options_schema(d.pop("configurationOptionsSchema", UNSET))
137
138        def _parse_environment_configuration(data: object) -> Union["AgentInputEnvironmentConfiguration", None, Unset]:
139            if data is None:
140                return data
141            if isinstance(data, Unset):
142                return data
143            try:
144                if not isinstance(data, dict):
145                    raise TypeError()
146                environment_configuration_type_0 = AgentInputEnvironmentConfiguration.from_dict(data)
147
148                return environment_configuration_type_0
149            except:  # noqa: E722
150                pass
151            return cast(Union["AgentInputEnvironmentConfiguration", None, Unset], data)
152
153        environment_configuration = _parse_environment_configuration(d.pop("environmentConfiguration", UNSET))
154
155        def _parse_tags(data: object) -> Union["AgentInputTags", None, Unset]:
156            if data is None:
157                return data
158            if isinstance(data, Unset):
159                return data
160            try:
161                if not isinstance(data, dict):
162                    raise TypeError()
163                tags_type_0 = AgentInputTags.from_dict(data)
164
165                return tags_type_0
166            except:  # noqa: E722
167                pass
168            return cast(Union["AgentInputTags", None, Unset], data)
169
170        tags = _parse_tags(d.pop("tags", UNSET))
171
172        agent_input = cls(
173            name=name,
174            agent_role_arn=agent_role_arn,
175            id=id,
176            configuration_options_schema=configuration_options_schema,
177            environment_configuration=environment_configuration,
178            tags=tags,
179        )
180
181        agent_input.additional_properties = d
182        return agent_input
183
184    @property
185    def additional_keys(self) -> List[str]:
186        return list(self.additional_properties.keys())