tower 0.3.4__py3-none-linux_armv6l.whl

tower/tower_api_client/models/refresh_session_response.py

@@ -0,0 +1,66 @@
+import datetime
+from typing import TYPE_CHECKING, Any, Dict, Type, TypeVar, Union
+
+import attr
+from dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.session import Session
+
+
+T = TypeVar("T", bound="RefreshSessionResponse")
+
+
+@attr.s(auto_attribs=True)
+class RefreshSessionResponse:
+    """
+    Attributes:
+        refreshed_at (datetime.datetime): A timestamp that indicates the last time the session data was refreshed.
+        session (Session):
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/RefreshSessionResponse.json.
+    """
+
+    refreshed_at: datetime.datetime
+    session: "Session"
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        refreshed_at = self.refreshed_at.isoformat()
+
+        session = self.session.to_dict()
+
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "refreshed_at": refreshed_at,
+                "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()
+        refreshed_at = isoparse(d.pop("refreshed_at"))
+
+        session = Session.from_dict(d.pop("session"))
+
+        schema = d.pop("$schema", UNSET)
+
+        refresh_session_response = cls(
+            refreshed_at=refreshed_at,
+            session=session,
+            schema=schema,
+        )
+
+        return refresh_session_response

tower/tower_api_client/models/remove_team_member_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="RemoveTeamMemberParams")
+
+
+@attr.s(auto_attribs=True)
+class RemoveTeamMemberParams:
+    """
+    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/RemoveTeamMemberParams.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)
+
+        remove_team_member_params = cls(
+            email=email,
+            schema=schema,
+        )
+
+        return remove_team_member_params

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

tower/tower_api_client/models/resend_team_invitation_params.py

@@ -0,0 +1,57 @@
+from typing import Any, Dict, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ResendTeamInvitationParams")
+
+
+@attr.s(auto_attribs=True)
+class ResendTeamInvitationParams:
+    """
+    Attributes:
+        email (str): The email address of team invitation to resend
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/ResendTeamInvitationParams.json.
+        message (Union[Unset, str]): Optional message to include in the invite email
+    """
+
+    email: str
+    schema: Union[Unset, str] = UNSET
+    message: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        email = self.email
+        schema = self.schema
+        message = self.message
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "email": email,
+            }
+        )
+        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()
+        email = d.pop("email")
+
+        schema = d.pop("$schema", UNSET)
+
+        message = d.pop("message", UNSET)
+
+        resend_team_invitation_params = cls(
+            email=email,
+            schema=schema,
+            message=message,
+        )
+
+        return resend_team_invitation_params

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

tower/tower_api_client/models/run.py

@@ -0,0 +1,129 @@
+import datetime
+from typing import Any, Dict, Optional, Type, TypeVar
+
+import attr
+from dateutil.parser import isoparse
+
+T = TypeVar("T", bound="Run")
+
+
+@attr.s(auto_attribs=True)
+class Run:
+    """
+    Attributes:
+        app_name (str):
+        created_at (datetime.datetime):
+        environment (str):
+        number (int):
+        run_id (str):
+        scheduled_at (datetime.datetime):
+        status (str):
+        status_group (str):
+        cancelled_at (Optional[datetime.datetime]):
+        ended_at (Optional[datetime.datetime]):
+        started_at (Optional[datetime.datetime]):
+    """
+
+    app_name: str
+    created_at: datetime.datetime
+    environment: str
+    number: int
+    run_id: str
+    scheduled_at: datetime.datetime
+    status: str
+    status_group: str
+    cancelled_at: Optional[datetime.datetime]
+    ended_at: Optional[datetime.datetime]
+    started_at: Optional[datetime.datetime]
+
+    def to_dict(self) -> Dict[str, Any]:
+        app_name = self.app_name
+        created_at = self.created_at.isoformat()
+
+        environment = self.environment
+        number = self.number
+        run_id = self.run_id
+        scheduled_at = self.scheduled_at.isoformat()
+
+        status = self.status
+        status_group = self.status_group
+        cancelled_at = self.cancelled_at.isoformat() if self.cancelled_at else None
+
+        ended_at = self.ended_at.isoformat() if self.ended_at else None
+
+        started_at = self.started_at.isoformat() if self.started_at else None
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "app_name": app_name,
+                "created_at": created_at,
+                "environment": environment,
+                "number": number,
+                "run_id": run_id,
+                "scheduled_at": scheduled_at,
+                "status": status,
+                "status_group": status_group,
+                "cancelled_at": cancelled_at,
+                "ended_at": ended_at,
+                "started_at": started_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        app_name = d.pop("app_name")
+
+        created_at = isoparse(d.pop("created_at"))
+
+        environment = d.pop("environment")
+
+        number = d.pop("number")
+
+        run_id = d.pop("run_id")
+
+        scheduled_at = isoparse(d.pop("scheduled_at"))
+
+        status = d.pop("status")
+
+        status_group = d.pop("status_group")
+
+        _cancelled_at = d.pop("cancelled_at")
+        cancelled_at: Optional[datetime.datetime]
+        if _cancelled_at is None:
+            cancelled_at = None
+        else:
+            cancelled_at = isoparse(_cancelled_at)
+
+        _ended_at = d.pop("ended_at")
+        ended_at: Optional[datetime.datetime]
+        if _ended_at is None:
+            ended_at = None
+        else:
+            ended_at = isoparse(_ended_at)
+
+        _started_at = d.pop("started_at")
+        started_at: Optional[datetime.datetime]
+        if _started_at is None:
+            started_at = None
+        else:
+            started_at = isoparse(_started_at)
+
+        run = cls(
+            app_name=app_name,
+            created_at=created_at,
+            environment=environment,
+            number=number,
+            run_id=run_id,
+            scheduled_at=scheduled_at,
+            status=status,
+            status_group=status_group,
+            cancelled_at=cancelled_at,
+            ended_at=ended_at,
+            started_at=started_at,
+        )
+
+        return run

tower/tower_api_client/models/run_app_params.py

@@ -0,0 +1,72 @@
+from typing import TYPE_CHECKING, Any, Dict, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.run_app_params_parameters import RunAppParamsParameters
+
+
+T = TypeVar("T", bound="RunAppParams")
+
+
+@attr.s(auto_attribs=True)
+class RunAppParams:
+    """
+    Attributes:
+        environment (str): The environment to run this app in.
+        parameters (RunAppParamsParameters): The parameters to pass into this app.
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/RunAppParams.json.
+        parent_run_id (Union[Unset, None, str]): The ID of the run that invoked this run, if relevant. Should be null,
+            if none.
+    """
+
+    environment: str
+    parameters: "RunAppParamsParameters"
+    schema: Union[Unset, str] = UNSET
+    parent_run_id: Union[Unset, None, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        environment = self.environment
+        parameters = self.parameters.to_dict()
+
+        schema = self.schema
+        parent_run_id = self.parent_run_id
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "environment": environment,
+                "parameters": parameters,
+            }
+        )
+        if schema is not UNSET:
+            field_dict["$schema"] = schema
+        if parent_run_id is not UNSET:
+            field_dict["parent_run_id"] = parent_run_id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.run_app_params_parameters import RunAppParamsParameters
+
+        d = src_dict.copy()
+        environment = d.pop("environment")
+
+        parameters = RunAppParamsParameters.from_dict(d.pop("parameters"))
+
+        schema = d.pop("$schema", UNSET)
+
+        parent_run_id = d.pop("parent_run_id", UNSET)
+
+        run_app_params = cls(
+            environment=environment,
+            parameters=parameters,
+            schema=schema,
+            parent_run_id=parent_run_id,
+        )
+
+        return run_app_params

tower/tower_api_client/models/run_app_params_parameters.py

@@ -0,0 +1,43 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+import attr
+
+T = TypeVar("T", bound="RunAppParamsParameters")
+
+
+@attr.s(auto_attribs=True)
+class RunAppParamsParameters:
+    """The parameters to pass into this app."""
+
+    additional_properties: Dict[str, str] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        run_app_params_parameters = cls()
+
+        run_app_params_parameters.additional_properties = d
+        return run_app_params_parameters
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

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

tower/tower_api_client/models/run_results.py

@@ -0,0 +1,73 @@
+from typing import Any, Dict, Type, TypeVar
+
+import attr
+
+T = TypeVar("T", bound="RunResults")
+
+
+@attr.s(auto_attribs=True)
+class RunResults:
+    """
+    Attributes:
+        cancelled (int):
+        crashed (int):
+        errored (int):
+        exited (int):
+        pending (int):
+        running (int):
+    """
+
+    cancelled: int
+    crashed: int
+    errored: int
+    exited: int
+    pending: int
+    running: int
+
+    def to_dict(self) -> Dict[str, Any]:
+        cancelled = self.cancelled
+        crashed = self.crashed
+        errored = self.errored
+        exited = self.exited
+        pending = self.pending
+        running = self.running
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "cancelled": cancelled,
+                "crashed": crashed,
+                "errored": errored,
+                "exited": exited,
+                "pending": pending,
+                "running": running,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        cancelled = d.pop("cancelled")
+
+        crashed = d.pop("crashed")
+
+        errored = d.pop("errored")
+
+        exited = d.pop("exited")
+
+        pending = d.pop("pending")
+
+        running = d.pop("running")
+
+        run_results = cls(
+            cancelled=cancelled,
+            crashed=crashed,
+            errored=errored,
+            exited=exited,
+            pending=pending,
+            running=running,
+        )
+
+        return run_results