tower 0.3.4__py3-none-linux_armv6l.whl

tower/tower_api_client/models/create_session_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="CreateSessionParams")
+
+
+@attr.s(auto_attribs=True)
+class CreateSessionParams:
+    """
+    Attributes:
+        password (str):
+        username (str):
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/CreateSessionParams.json.
+    """
+
+    password: str
+    username: str
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        password = self.password
+        username = self.username
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "password": password,
+                "username": username,
+            }
+        )
+        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()
+        password = d.pop("password")
+
+        username = d.pop("username")
+
+        schema = d.pop("$schema", UNSET)
+
+        create_session_params = cls(
+            password=password,
+            username=username,
+            schema=schema,
+        )
+
+        return create_session_params

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

tower/tower_api_client/models/create_team_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="CreateTeamParams")
+
+
+@attr.s(auto_attribs=True)
+class CreateTeamParams:
+    """
+    Attributes:
+        name (str): The name of the team to create
+        slug (str): The slug of the team to create
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/CreateTeamParams.json.
+    """
+
+    name: str
+    slug: str
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        name = self.name
+        slug = self.slug
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "name": name,
+                "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()
+        name = d.pop("name")
+
+        slug = d.pop("slug")
+
+        schema = d.pop("$schema", UNSET)
+
+        create_team_params = cls(
+            name=name,
+            slug=slug,
+            schema=schema,
+        )
+
+        return create_team_params

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

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

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

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

tower/tower_api_client/models/delete_team_invitation_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="DeleteTeamInvitationParams")
+
+
+@attr.s(auto_attribs=True)
+class DeleteTeamInvitationParams:
+    """
+    Attributes:
+        email (str): The email address of the team member to remove
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/DeleteTeamInvitationParams.json.
+    """
+
+    email: str
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        email = self.email
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "email": email,
+            }
+        )
+        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()
+        email = d.pop("email")
+
+        schema = d.pop("$schema", UNSET)
+
+        delete_team_invitation_params = cls(
+            email=email,
+            schema=schema,
+        )
+
+        return delete_team_invitation_params

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

tower/tower_api_client/models/delete_team_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="DeleteTeamParams")
+
+
+@attr.s(auto_attribs=True)
+class DeleteTeamParams:
+    """
+    Attributes:
+        slug (str): The slug of the team to delete
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/DeleteTeamParams.json.
+    """
+
+    slug: str
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        slug = self.slug
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "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()
+        slug = d.pop("slug")
+
+        schema = d.pop("$schema", UNSET)
+
+        delete_team_params = cls(
+            slug=slug,
+            schema=schema,
+        )
+
+        return delete_team_params

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

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