tower 0.3.4__py3-none-linux_armv6l.whl

tower/tower_api_client/models/run_statistics.py

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

tower/tower_api_client/models/secret.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="Secret")
+
+
+@attr.s(auto_attribs=True)
+class Secret:
+    """
+    Attributes:
+        created_at (datetime.datetime):
+        environment (str):
+        name (str):
+        preview (str):
+    """
+
+    created_at: datetime.datetime
+    environment: str
+    name: str
+    preview: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        created_at = self.created_at.isoformat()
+
+        environment = self.environment
+        name = self.name
+        preview = self.preview
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "created_at": created_at,
+                "environment": environment,
+                "name": name,
+                "preview": preview,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        created_at = isoparse(d.pop("created_at"))
+
+        environment = d.pop("environment")
+
+        name = d.pop("name")
+
+        preview = d.pop("preview")
+
+        secret = cls(
+            created_at=created_at,
+            environment=environment,
+            name=name,
+            preview=preview,
+        )
+
+        return secret

tower/tower_api_client/models/series_point.py

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

tower/tower_api_client/models/session.py

@@ -0,0 +1,73 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar
+
+import attr
+
+if TYPE_CHECKING:
+    from ..models.team import Team
+    from ..models.token import Token
+    from ..models.user import User
+
+
+T = TypeVar("T", bound="Session")
+
+
+@attr.s(auto_attribs=True)
+class Session:
+    """
+    Attributes:
+        teams (List['Team']):
+        token (Token):
+        user (User):
+    """
+
+    teams: List["Team"]
+    token: "Token"
+    user: "User"
+
+    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)
+
+        token = self.token.to_dict()
+
+        user = self.user.to_dict()
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "teams": teams,
+                "token": token,
+                "user": user,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.team import Team
+        from ..models.token import Token
+        from ..models.user import User
+
+        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)
+
+        token = Token.from_dict(d.pop("token"))
+
+        user = User.from_dict(d.pop("user"))
+
+        session = cls(
+            teams=teams,
+            token=token,
+            user=user,
+        )
+
+        return session

tower/tower_api_client/models/statistics_settings.py

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

tower/tower_api_client/models/team.py

@@ -0,0 +1,75 @@
+from typing import TYPE_CHECKING, Any, Dict, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.token import Token
+
+
+T = TypeVar("T", bound="Team")
+
+
+@attr.s(auto_attribs=True)
+class Team:
+    """
+    Attributes:
+        name (str):
+        slug (str):
+        type (str): The type of team, either 'personal' or 'team'.
+        token (Union[Unset, Token]):
+    """
+
+    name: str
+    slug: str
+    type: str
+    token: Union[Unset, "Token"] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        name = self.name
+        slug = self.slug
+        type = self.type
+        token: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.token, Unset):
+            token = self.token.to_dict()
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "name": name,
+                "slug": slug,
+                "type": type,
+            }
+        )
+        if token is not UNSET:
+            field_dict["token"] = token
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.token import Token
+
+        d = src_dict.copy()
+        name = d.pop("name")
+
+        slug = d.pop("slug")
+
+        type = d.pop("type")
+
+        _token = d.pop("token", UNSET)
+        token: Union[Unset, Token]
+        if isinstance(_token, Unset):
+            token = UNSET
+        else:
+            token = Token.from_dict(_token)
+
+        team = cls(
+            name=name,
+            slug=slug,
+            type=type,
+            token=token,
+        )
+
+        return team

tower/tower_api_client/models/team_invitation.py

@@ -0,0 +1,61 @@
+import datetime
+from typing import TYPE_CHECKING, Any, Dict, Type, TypeVar
+
+import attr
+from dateutil.parser import isoparse
+
+if TYPE_CHECKING:
+    from ..models.team import Team
+
+
+T = TypeVar("T", bound="TeamInvitation")
+
+
+@attr.s(auto_attribs=True)
+class TeamInvitation:
+    """
+    Attributes:
+        email (str):
+        invitation_sent_at (datetime.datetime):
+        team (Team):
+    """
+
+    email: str
+    invitation_sent_at: datetime.datetime
+    team: "Team"
+
+    def to_dict(self) -> Dict[str, Any]:
+        email = self.email
+        invitation_sent_at = self.invitation_sent_at.isoformat()
+
+        team = self.team.to_dict()
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "email": email,
+                "invitation_sent_at": invitation_sent_at,
+                "team": team,
+            }
+        )
+
+        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()
+        email = d.pop("email")
+
+        invitation_sent_at = isoparse(d.pop("invitation_sent_at"))
+
+        team = Team.from_dict(d.pop("team"))
+
+        team_invitation = cls(
+            email=email,
+            invitation_sent_at=invitation_sent_at,
+            team=team,
+        )
+
+        return team_invitation

tower/tower_api_client/models/token.py

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

tower/tower_api_client/models/update_account_slug_params.py

@@ -0,0 +1,49 @@
+from typing import Any, Dict, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="UpdateAccountSlugParams")
+
+
+@attr.s(auto_attribs=True)
+class UpdateAccountSlugParams:
+    """
+    Attributes:
+        new_slug (str): The new slug for the account
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/UpdateAccountSlugParams.json.
+    """
+
+    new_slug: str
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        new_slug = self.new_slug
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "new_slug": new_slug,
+            }
+        )
+        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()
+        new_slug = d.pop("new_slug")
+
+        schema = d.pop("$schema", UNSET)
+
+        update_account_slug_params = cls(
+            new_slug=new_slug,
+            schema=schema,
+        )
+
+        return update_account_slug_params

tower/tower_api_client/models/update_account_slug_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.account import Account
+
+
+T = TypeVar("T", bound="UpdateAccountSlugResponse")
+
+
+@attr.s(auto_attribs=True)
+class UpdateAccountSlugResponse:
+    """
+    Attributes:
+        account (Account):
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/UpdateAccountSlugResponse.json.
+    """
+
+    account: "Account"
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        account = self.account.to_dict()
+
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "account": account,
+            }
+        )
+        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.account import Account
+
+        d = src_dict.copy()
+        account = Account.from_dict(d.pop("account"))
+
+        schema = d.pop("$schema", UNSET)
+
+        update_account_slug_response = cls(
+            account=account,
+            schema=schema,
+        )
+
+        return update_account_slug_response

tower/tower_api_client/models/update_my_team_invitation_params.py

@@ -0,0 +1,56 @@
+from typing import Any, Dict, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="UpdateMyTeamInvitationParams")
+
+
+@attr.s(auto_attribs=True)
+class UpdateMyTeamInvitationParams:
+    """
+    Attributes:
+        accepted (bool): Whether or not the invitation was accepted. If false, it's considered rejected.
+        slug (str): The slug of the team invitation to update
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/UpdateMyTeamInvitationParams.json.
+    """
+
+    accepted: bool
+    slug: str
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        accepted = self.accepted
+        slug = self.slug
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "accepted": accepted,
+                "slug": slug,
+            }
+        )
+        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()
+        accepted = d.pop("accepted")
+
+        slug = d.pop("slug")
+
+        schema = d.pop("$schema", UNSET)
+
+        update_my_team_invitation_params = cls(
+            accepted=accepted,
+            slug=slug,
+            schema=schema,
+        )
+
+        return update_my_team_invitation_params

tower/tower_api_client/models/update_my_team_invitation_response.py

@@ -0,0 +1,39 @@
+from typing import Any, Dict, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="UpdateMyTeamInvitationResponse")
+
+
+@attr.s(auto_attribs=True)
+class UpdateMyTeamInvitationResponse:
+    """
+    Attributes:
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/UpdateMyTeamInvitationResponse.json.
+    """
+
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update({})
+        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()
+        schema = d.pop("$schema", UNSET)
+
+        update_my_team_invitation_response = cls(
+            schema=schema,
+        )
+
+        return update_my_team_invitation_response