tower 0.3.4__py3-none-linux_armv6l.whl

tower/tower_api_client/models/generate_app_statistics_response.py

@@ -0,0 +1,56 @@
+from typing import TYPE_CHECKING, Any, Dict, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.app_statistics import AppStatistics
+
+
+T = TypeVar("T", bound="GenerateAppStatisticsResponse")
+
+
+@attr.s(auto_attribs=True)
+class GenerateAppStatisticsResponse:
+    """
+    Attributes:
+        statistics (AppStatistics):
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/GenerateAppStatisticsResponse.json.
+    """
+
+    statistics: "AppStatistics"
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        statistics = self.statistics.to_dict()
+
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "statistics": statistics,
+            }
+        )
+        if schema is not UNSET:
+            field_dict["$schema"] = schema
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.app_statistics import AppStatistics
+
+        d = src_dict.copy()
+        statistics = AppStatistics.from_dict(d.pop("statistics"))
+
+        schema = d.pop("$schema", UNSET)
+
+        generate_app_statistics_response = cls(
+            statistics=statistics,
+            schema=schema,
+        )
+
+        return generate_app_statistics_response

tower/tower_api_client/models/generate_run_statistics_response.py

@@ -0,0 +1,85 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.run_statistics import RunStatistics
+    from ..models.series_point import SeriesPoint
+    from ..models.statistics_settings import StatisticsSettings
+
+
+T = TypeVar("T", bound="GenerateRunStatisticsResponse")
+
+
+@attr.s(auto_attribs=True)
+class GenerateRunStatisticsResponse:
+    """
+    Attributes:
+        series (List['SeriesPoint']):
+        settings (StatisticsSettings):
+        stats (RunStatistics):
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/GenerateRunStatisticsResponse.json.
+    """
+
+    series: List["SeriesPoint"]
+    settings: "StatisticsSettings"
+    stats: "RunStatistics"
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        series = []
+        for series_item_data in self.series:
+            series_item = series_item_data.to_dict()
+
+            series.append(series_item)
+
+        settings = self.settings.to_dict()
+
+        stats = self.stats.to_dict()
+
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "series": series,
+                "settings": settings,
+                "stats": stats,
+            }
+        )
+        if schema is not UNSET:
+            field_dict["$schema"] = schema
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.run_statistics import RunStatistics
+        from ..models.series_point import SeriesPoint
+        from ..models.statistics_settings import StatisticsSettings
+
+        d = src_dict.copy()
+        series = []
+        _series = d.pop("series")
+        for series_item_data in _series:
+            series_item = SeriesPoint.from_dict(series_item_data)
+
+            series.append(series_item)
+
+        settings = StatisticsSettings.from_dict(d.pop("settings"))
+
+        stats = RunStatistics.from_dict(d.pop("stats"))
+
+        schema = d.pop("$schema", UNSET)
+
+        generate_run_statistics_response = cls(
+            series=series,
+            settings=settings,
+            stats=stats,
+            schema=schema,
+        )
+
+        return generate_run_statistics_response

tower/tower_api_client/models/get_run_log_line.py

@@ -0,0 +1,47 @@
+import datetime
+from typing import Any, Dict, Type, TypeVar
+
+import attr
+from dateutil.parser import isoparse
+
+T = TypeVar("T", bound="GetRunLogLine")
+
+
+@attr.s(auto_attribs=True)
+class GetRunLogLine:
+    """
+    Attributes:
+        message (str):
+        timestamp (datetime.datetime):
+    """
+
+    message: str
+    timestamp: datetime.datetime
+
+    def to_dict(self) -> Dict[str, Any]:
+        message = self.message
+        timestamp = self.timestamp.isoformat()
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "message": message,
+                "timestamp": timestamp,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        message = d.pop("message")
+
+        timestamp = isoparse(d.pop("timestamp"))
+
+        get_run_log_line = cls(
+            message=message,
+            timestamp=timestamp,
+        )
+
+        return get_run_log_line

tower/tower_api_client/models/get_run_logs_output_body.py

@@ -0,0 +1,65 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.get_run_log_line import GetRunLogLine
+
+
+T = TypeVar("T", bound="GetRunLogsOutputBody")
+
+
+@attr.s(auto_attribs=True)
+class GetRunLogsOutputBody:
+    """
+    Attributes:
+        log_lines (List['GetRunLogLine']):
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/GetRunLogsOutputBody.json.
+    """
+
+    log_lines: List["GetRunLogLine"]
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        log_lines = []
+        for log_lines_item_data in self.log_lines:
+            log_lines_item = log_lines_item_data.to_dict()
+
+            log_lines.append(log_lines_item)
+
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "log_lines": log_lines,
+            }
+        )
+        if schema is not UNSET:
+            field_dict["$schema"] = schema
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.get_run_log_line import GetRunLogLine
+
+        d = src_dict.copy()
+        log_lines = []
+        _log_lines = d.pop("log_lines")
+        for log_lines_item_data in _log_lines:
+            log_lines_item = GetRunLogLine.from_dict(log_lines_item_data)
+
+            log_lines.append(log_lines_item)
+
+        schema = d.pop("$schema", UNSET)
+
+        get_run_logs_output_body = cls(
+            log_lines=log_lines,
+            schema=schema,
+        )
+
+        return get_run_logs_output_body

tower/tower_api_client/models/invite_team_member_params.py

@@ -0,0 +1,58 @@
+from typing import Any, Dict, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="InviteTeamMemberParams")
+
+
+@attr.s(auto_attribs=True)
+class InviteTeamMemberParams:
+    """
+    Attributes:
+        emails (str): The email addresses of the people to invite. It can be a list in any format (comma separated,
+            newline separated, etc.) and it will be parsed into individual addresses
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/InviteTeamMemberParams.json.
+        message (Union[Unset, str]): Optional message to include in the invite email
+    """
+
+    emails: str
+    schema: Union[Unset, str] = UNSET
+    message: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        emails = self.emails
+        schema = self.schema
+        message = self.message
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "emails": emails,
+            }
+        )
+        if schema is not UNSET:
+            field_dict["$schema"] = schema
+        if message is not UNSET:
+            field_dict["message"] = message
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        emails = d.pop("emails")
+
+        schema = d.pop("$schema", UNSET)
+
+        message = d.pop("message", UNSET)
+
+        invite_team_member_params = cls(
+            emails=emails,
+            schema=schema,
+            message=message,
+        )
+
+        return invite_team_member_params

tower/tower_api_client/models/invite_team_member_response.py

@@ -0,0 +1,65 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.team_invitation import TeamInvitation
+
+
+T = TypeVar("T", bound="InviteTeamMemberResponse")
+
+
+@attr.s(auto_attribs=True)
+class InviteTeamMemberResponse:
+    """
+    Attributes:
+        team_invitations (List['TeamInvitation']): The team invitation that you created
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/InviteTeamMemberResponse.json.
+    """
+
+    team_invitations: List["TeamInvitation"]
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        team_invitations = []
+        for team_invitations_item_data in self.team_invitations:
+            team_invitations_item = team_invitations_item_data.to_dict()
+
+            team_invitations.append(team_invitations_item)
+
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "team_invitations": team_invitations,
+            }
+        )
+        if schema is not UNSET:
+            field_dict["$schema"] = schema
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.team_invitation import TeamInvitation
+
+        d = src_dict.copy()
+        team_invitations = []
+        _team_invitations = d.pop("team_invitations")
+        for team_invitations_item_data in _team_invitations:
+            team_invitations_item = TeamInvitation.from_dict(team_invitations_item_data)
+
+            team_invitations.append(team_invitations_item)
+
+        schema = d.pop("$schema", UNSET)
+
+        invite_team_member_response = cls(
+            team_invitations=team_invitations,
+            schema=schema,
+        )
+
+        return invite_team_member_response

tower/tower_api_client/models/leave_team_response.py

@@ -0,0 +1,56 @@
+from typing import TYPE_CHECKING, Any, Dict, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.team import Team
+
+
+T = TypeVar("T", bound="LeaveTeamResponse")
+
+
+@attr.s(auto_attribs=True)
+class LeaveTeamResponse:
+    """
+    Attributes:
+        team (Team):
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/LeaveTeamResponse.json.
+    """
+
+    team: "Team"
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        team = self.team.to_dict()
+
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "team": team,
+            }
+        )
+        if schema is not UNSET:
+            field_dict["$schema"] = schema
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.team import Team
+
+        d = src_dict.copy()
+        team = Team.from_dict(d.pop("team"))
+
+        schema = d.pop("$schema", UNSET)
+
+        leave_team_response = cls(
+            team=team,
+            schema=schema,
+        )
+
+        return leave_team_response

tower/tower_api_client/models/list_api_keys_response.py

@@ -0,0 +1,65 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.api_key import APIKey
+
+
+T = TypeVar("T", bound="ListAPIKeysResponse")
+
+
+@attr.s(auto_attribs=True)
+class ListAPIKeysResponse:
+    """
+    Attributes:
+        api_keys (List['APIKey']): List of API keys
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/ListAPIKeysResponse.json.
+    """
+
+    api_keys: List["APIKey"]
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        api_keys = []
+        for api_keys_item_data in self.api_keys:
+            api_keys_item = api_keys_item_data.to_dict()
+
+            api_keys.append(api_keys_item)
+
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "api_keys": api_keys,
+            }
+        )
+        if schema is not UNSET:
+            field_dict["$schema"] = schema
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.api_key import APIKey
+
+        d = src_dict.copy()
+        api_keys = []
+        _api_keys = d.pop("api_keys")
+        for api_keys_item_data in _api_keys:
+            api_keys_item = APIKey.from_dict(api_keys_item_data)
+
+            api_keys.append(api_keys_item)
+
+        schema = d.pop("$schema", UNSET)
+
+        list_api_keys_response = cls(
+            api_keys=api_keys,
+            schema=schema,
+        )
+
+        return list_api_keys_response

tower/tower_api_client/models/list_app_environments_response.py

@@ -0,0 +1,50 @@
+from typing import Any, Dict, List, Type, TypeVar, Union, cast
+
+import attr
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ListAppEnvironmentsResponse")
+
+
+@attr.s(auto_attribs=True)
+class ListAppEnvironmentsResponse:
+    """
+    Attributes:
+        environments (List[str]):
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/ListAppEnvironmentsResponse.json.
+    """
+
+    environments: List[str]
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        environments = self.environments
+
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "environments": environments,
+            }
+        )
+        if schema is not UNSET:
+            field_dict["$schema"] = schema
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        environments = cast(List[str], d.pop("environments"))
+
+        schema = d.pop("$schema", UNSET)
+
+        list_app_environments_response = cls(
+            environments=environments,
+            schema=schema,
+        )
+
+        return list_app_environments_response

tower/tower_api_client/models/list_app_versions_response.py

@@ -0,0 +1,65 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.app_version import AppVersion
+
+
+T = TypeVar("T", bound="ListAppVersionsResponse")
+
+
+@attr.s(auto_attribs=True)
+class ListAppVersionsResponse:
+    """
+    Attributes:
+        versions (List['AppVersion']):
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/ListAppVersionsResponse.json.
+    """
+
+    versions: List["AppVersion"]
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        versions = []
+        for versions_item_data in self.versions:
+            versions_item = versions_item_data.to_dict()
+
+            versions.append(versions_item)
+
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "versions": versions,
+            }
+        )
+        if schema is not UNSET:
+            field_dict["$schema"] = schema
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.app_version import AppVersion
+
+        d = src_dict.copy()
+        versions = []
+        _versions = d.pop("versions")
+        for versions_item_data in _versions:
+            versions_item = AppVersion.from_dict(versions_item_data)
+
+            versions.append(versions_item)
+
+        schema = d.pop("$schema", UNSET)
+
+        list_app_versions_response = cls(
+            versions=versions,
+            schema=schema,
+        )
+
+        return list_app_versions_response

tower/tower_api_client/models/list_apps_response.py

@@ -0,0 +1,75 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.app_summary import AppSummary
+    from ..models.pagination import Pagination
+
+
+T = TypeVar("T", bound="ListAppsResponse")
+
+
+@attr.s(auto_attribs=True)
+class ListAppsResponse:
+    """
+    Attributes:
+        apps (List['AppSummary']):
+        pages (Pagination):
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/ListAppsResponse.json.
+    """
+
+    apps: List["AppSummary"]
+    pages: "Pagination"
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        apps = []
+        for apps_item_data in self.apps:
+            apps_item = apps_item_data.to_dict()
+
+            apps.append(apps_item)
+
+        pages = self.pages.to_dict()
+
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "apps": apps,
+                "pages": pages,
+            }
+        )
+        if schema is not UNSET:
+            field_dict["$schema"] = schema
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.app_summary import AppSummary
+        from ..models.pagination import Pagination
+
+        d = src_dict.copy()
+        apps = []
+        _apps = d.pop("apps")
+        for apps_item_data in _apps:
+            apps_item = AppSummary.from_dict(apps_item_data)
+
+            apps.append(apps_item)
+
+        pages = Pagination.from_dict(d.pop("pages"))
+
+        schema = d.pop("$schema", UNSET)
+
+        list_apps_response = cls(
+            apps=apps,
+            pages=pages,
+            schema=schema,
+        )
+
+        return list_apps_response

tower/tower_api_client/models/list_apps_status_item.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class ListAppsStatusItem(str, Enum):
+    ACTIVE = "active"
+    FAILED = "failed"
+    DISABLED = "disabled"
+    RUNNING = "running"
+
+    def __str__(self) -> str:
+        return str(self.value)