tower 0.3.4__py3-none-linux_armv6l.whl

tower/tower_api_client/models/list_my_team_invitations_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="ListMyTeamInvitationsResponse")
+
+
+@attr.s(auto_attribs=True)
+class ListMyTeamInvitationsResponse:
+    """
+    Attributes:
+        team_invitations (List['TeamInvitation']): All of team invitations
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/ListMyTeamInvitationsResponse.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)
+
+        list_my_team_invitations_response = cls(
+            team_invitations=team_invitations,
+            schema=schema,
+        )
+
+        return list_my_team_invitations_response

tower/tower_api_client/models/list_runs_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.pagination import Pagination
+    from ..models.run import Run
+
+
+T = TypeVar("T", bound="ListRunsResponse")
+
+
+@attr.s(auto_attribs=True)
+class ListRunsResponse:
+    """
+    Attributes:
+        pages (Pagination):
+        runs (List['Run']):
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/ListRunsResponse.json.
+    """
+
+    pages: "Pagination"
+    runs: List["Run"]
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        pages = self.pages.to_dict()
+
+        runs = []
+        for runs_item_data in self.runs:
+            runs_item = runs_item_data.to_dict()
+
+            runs.append(runs_item)
+
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "pages": pages,
+                "runs": runs,
+            }
+        )
+        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.pagination import Pagination
+        from ..models.run import Run
+
+        d = src_dict.copy()
+        pages = Pagination.from_dict(d.pop("pages"))
+
+        runs = []
+        _runs = d.pop("runs")
+        for runs_item_data in _runs:
+            runs_item = Run.from_dict(runs_item_data)
+
+            runs.append(runs_item)
+
+        schema = d.pop("$schema", UNSET)
+
+        list_runs_response = cls(
+            pages=pages,
+            runs=runs,
+            schema=schema,
+        )
+
+        return list_runs_response

tower/tower_api_client/models/list_secret_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="ListSecretEnvironmentsResponse")
+
+
+@attr.s(auto_attribs=True)
+class ListSecretEnvironmentsResponse:
+    """
+    Attributes:
+        environments (List[str]):
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/ListSecretEnvironmentsResponse.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_secret_environments_response = cls(
+            environments=environments,
+            schema=schema,
+        )
+
+        return list_secret_environments_response

tower/tower_api_client/models/list_secrets_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.pagination import Pagination
+    from ..models.secret import Secret
+
+
+T = TypeVar("T", bound="ListSecretsResponse")
+
+
+@attr.s(auto_attribs=True)
+class ListSecretsResponse:
+    """
+    Attributes:
+        pages (Pagination):
+        secrets (List['Secret']):
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/ListSecretsResponse.json.
+    """
+
+    pages: "Pagination"
+    secrets: List["Secret"]
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        pages = self.pages.to_dict()
+
+        secrets = []
+        for secrets_item_data in self.secrets:
+            secrets_item = secrets_item_data.to_dict()
+
+            secrets.append(secrets_item)
+
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "pages": pages,
+                "secrets": secrets,
+            }
+        )
+        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.pagination import Pagination
+        from ..models.secret import Secret
+
+        d = src_dict.copy()
+        pages = Pagination.from_dict(d.pop("pages"))
+
+        secrets = []
+        _secrets = d.pop("secrets")
+        for secrets_item_data in _secrets:
+            secrets_item = Secret.from_dict(secrets_item_data)
+
+            secrets.append(secrets_item)
+
+        schema = d.pop("$schema", UNSET)
+
+        list_secrets_response = cls(
+            pages=pages,
+            secrets=secrets,
+            schema=schema,
+        )
+
+        return list_secrets_response

tower/tower_api_client/models/list_team_invitations_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="ListTeamInvitationsResponse")
+
+
+@attr.s(auto_attribs=True)
+class ListTeamInvitationsResponse:
+    """
+    Attributes:
+        team_invitations (List['TeamInvitation']): All of team invitations
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/ListTeamInvitationsResponse.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)
+
+        list_team_invitations_response = cls(
+            team_invitations=team_invitations,
+            schema=schema,
+        )
+
+        return list_team_invitations_response

tower/tower_api_client/models/list_team_members_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.user import User
+
+
+T = TypeVar("T", bound="ListTeamMembersResponse")
+
+
+@attr.s(auto_attribs=True)
+class ListTeamMembersResponse:
+    """
+    Attributes:
+        team_members (List['User']): All of the members of a team
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/ListTeamMembersResponse.json.
+    """
+
+    team_members: List["User"]
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        team_members = []
+        for team_members_item_data in self.team_members:
+            team_members_item = team_members_item_data.to_dict()
+
+            team_members.append(team_members_item)
+
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "team_members": team_members,
+            }
+        )
+        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.user import User
+
+        d = src_dict.copy()
+        team_members = []
+        _team_members = d.pop("team_members")
+        for team_members_item_data in _team_members:
+            team_members_item = User.from_dict(team_members_item_data)
+
+            team_members.append(team_members_item)
+
+        schema = d.pop("$schema", UNSET)
+
+        list_team_members_response = cls(
+            team_members=team_members,
+            schema=schema,
+        )
+
+        return list_team_members_response

tower/tower_api_client/models/list_teams_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 import Team
+
+
+T = TypeVar("T", bound="ListTeamsResponse")
+
+
+@attr.s(auto_attribs=True)
+class ListTeamsResponse:
+    """
+    Attributes:
+        teams (List['Team']): List of teams
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/ListTeamsResponse.json.
+    """
+
+    teams: List["Team"]
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        teams = []
+        for teams_item_data in self.teams:
+            teams_item = teams_item_data.to_dict()
+
+            teams.append(teams_item)
+
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "teams": teams,
+            }
+        )
+        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()
+        teams = []
+        _teams = d.pop("teams")
+        for teams_item_data in _teams:
+            teams_item = Team.from_dict(teams_item_data)
+
+            teams.append(teams_item)
+
+        schema = d.pop("$schema", UNSET)
+
+        list_teams_response = cls(
+            teams=teams,
+            schema=schema,
+        )
+
+        return list_teams_response

tower/tower_api_client/models/log_line.py

@@ -0,0 +1,62 @@
+import datetime
+from typing import Any, Dict, Type, TypeVar
+
+import attr
+from dateutil.parser import isoparse
+
+T = TypeVar("T", bound="LogLine")
+
+
+@attr.s(auto_attribs=True)
+class LogLine:
+    """
+    Attributes:
+        content (str): Contents of the log message.
+        line_num (int): Line number.
+        reported_at (datetime.datetime): Timestamp of the log line.
+        run_id (str): The uuid of the Run.
+    """
+
+    content: str
+    line_num: int
+    reported_at: datetime.datetime
+    run_id: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        content = self.content
+        line_num = self.line_num
+        reported_at = self.reported_at.isoformat()
+
+        run_id = self.run_id
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "content": content,
+                "line_num": line_num,
+                "reported_at": reported_at,
+                "run_id": run_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        content = d.pop("content")
+
+        line_num = d.pop("line_num")
+
+        reported_at = isoparse(d.pop("reported_at"))
+
+        run_id = d.pop("run_id")
+
+        log_line = cls(
+            content=content,
+            line_num=line_num,
+            reported_at=reported_at,
+            run_id=run_id,
+        )
+
+        return log_line

tower/tower_api_client/models/log_line_error.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="LogLineError")
+
+
+@attr.s(auto_attribs=True)
+class LogLineError:
+    """
+    Attributes:
+        content (str): Contents of the error.
+        reported_at (datetime.datetime): Timestamp of the event.
+    """
+
+    content: str
+    reported_at: datetime.datetime
+
+    def to_dict(self) -> Dict[str, Any]:
+        content = self.content
+        reported_at = self.reported_at.isoformat()
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "content": content,
+                "reported_at": reported_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        content = d.pop("content")
+
+        reported_at = isoparse(d.pop("reported_at"))
+
+        log_line_error = cls(
+            content=content,
+            reported_at=reported_at,
+        )
+
+        return log_line_error

tower/tower_api_client/models/pagination.py

@@ -0,0 +1,59 @@
+from typing import Any, Dict, Type, TypeVar
+
+import attr
+
+T = TypeVar("T", bound="Pagination")
+
+
+@attr.s(auto_attribs=True)
+class Pagination:
+    """
+    Attributes:
+        num_pages (int):
+        page (int):
+        page_size (int):
+        total (int):
+    """
+
+    num_pages: int
+    page: int
+    page_size: int
+    total: int
+
+    def to_dict(self) -> Dict[str, Any]:
+        num_pages = self.num_pages
+        page = self.page
+        page_size = self.page_size
+        total = self.total
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "num_pages": num_pages,
+                "page": page,
+                "page_size": page_size,
+                "total": total,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        num_pages = d.pop("num_pages")
+
+        page = d.pop("page")
+
+        page_size = d.pop("page_size")
+
+        total = d.pop("total")
+
+        pagination = cls(
+            num_pages=num_pages,
+            page=page,
+            page_size=page_size,
+            total=total,
+        )
+
+        return pagination

tower/tower_api_client/models/parameter.py

@@ -0,0 +1,52 @@
+from typing import Any, Dict, Type, TypeVar
+
+import attr
+
+T = TypeVar("T", bound="Parameter")
+
+
+@attr.s(auto_attribs=True)
+class Parameter:
+    """
+    Attributes:
+        default (str):
+        description (str):
+        name (str):
+    """
+
+    default: str
+    description: str
+    name: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        default = self.default
+        description = self.description
+        name = self.name
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "default": default,
+                "description": description,
+                "name": name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        default = d.pop("default")
+
+        description = d.pop("description")
+
+        name = d.pop("name")
+
+        parameter = cls(
+            default=default,
+            description=description,
+            name=name,
+        )
+
+        return parameter