tower 0.3.4__py3-none-linux_armv6l.whl

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

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

tower/tower_api_client/models/account.py

@@ -0,0 +1,45 @@
+from typing import Any, Dict, Type, TypeVar
+
+import attr
+
+T = TypeVar("T", bound="Account")
+
+
+@attr.s(auto_attribs=True)
+class Account:
+    """
+    Attributes:
+        name (str):
+        slug (str):
+    """
+
+    name: str
+    slug: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        name = self.name
+        slug = self.slug
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "name": name,
+                "slug": slug,
+            }
+        )
+
+        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")
+
+        account = cls(
+            name=name,
+            slug=slug,
+        )
+
+        return account

tower/tower_api_client/models/api_key.py

@@ -0,0 +1,67 @@
+import datetime
+from typing import Any, Dict, Optional, Type, TypeVar
+
+import attr
+from dateutil.parser import isoparse
+
+T = TypeVar("T", bound="APIKey")
+
+
+@attr.s(auto_attribs=True)
+class APIKey:
+    """
+    Attributes:
+        created_at (datetime.datetime):
+        identifier (str):
+        name (str):
+        last_used_at (Optional[datetime.datetime]):
+    """
+
+    created_at: datetime.datetime
+    identifier: str
+    name: str
+    last_used_at: Optional[datetime.datetime]
+
+    def to_dict(self) -> Dict[str, Any]:
+        created_at = self.created_at.isoformat()
+
+        identifier = self.identifier
+        name = self.name
+        last_used_at = self.last_used_at.isoformat() if self.last_used_at else None
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "created_at": created_at,
+                "identifier": identifier,
+                "name": name,
+                "last_used_at": last_used_at,
+            }
+        )
+
+        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"))
+
+        identifier = d.pop("identifier")
+
+        name = d.pop("name")
+
+        _last_used_at = d.pop("last_used_at")
+        last_used_at: Optional[datetime.datetime]
+        if _last_used_at is None:
+            last_used_at = None
+        else:
+            last_used_at = isoparse(_last_used_at)
+
+        api_key = cls(
+            created_at=created_at,
+            identifier=identifier,
+            name=name,
+            last_used_at=last_used_at,
+        )
+
+        return api_key

tower/tower_api_client/models/app.py

@@ -0,0 +1,122 @@
+import datetime
+from typing import TYPE_CHECKING, Any, Dict, Optional, Type, TypeVar, Union
+
+import attr
+from dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.run import Run
+
+
+T = TypeVar("T", bound="App")
+
+
+@attr.s(auto_attribs=True)
+class App:
+    """
+    Attributes:
+        created_at (datetime.datetime): The date and time this app was created.
+        name (str): The name of the app.
+        owner (str): The account slug that owns this app
+        short_description (str): A short description of the app. Can be empty.
+        last_run (Union[Unset, Run]):
+        next_run_at (Optional[datetime.datetime]): The next time this app will run as part of it's schedule, null if
+            none.
+        schedule (Optional[str]): The schedule associated with this app, null if none.
+        status (Union[Unset, str]): The status of the app
+        version (Optional[str]): The current version of this app, null if none.
+    """
+
+    created_at: datetime.datetime
+    name: str
+    owner: str
+    short_description: str
+    next_run_at: Optional[datetime.datetime]
+    schedule: Optional[str]
+    version: Optional[str]
+    last_run: Union[Unset, "Run"] = UNSET
+    status: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        created_at = self.created_at.isoformat()
+
+        name = self.name
+        owner = self.owner
+        short_description = self.short_description
+        last_run: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.last_run, Unset):
+            last_run = self.last_run.to_dict()
+
+        next_run_at = self.next_run_at.isoformat() if self.next_run_at else None
+
+        schedule = self.schedule
+        status = self.status
+        version = self.version
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "created_at": created_at,
+                "name": name,
+                "owner": owner,
+                "short_description": short_description,
+                "next_run_at": next_run_at,
+                "schedule": schedule,
+                "version": version,
+            }
+        )
+        if last_run is not UNSET:
+            field_dict["last_run"] = last_run
+        if status is not UNSET:
+            field_dict["status"] = status
+
+        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()
+        created_at = isoparse(d.pop("created_at"))
+
+        name = d.pop("name")
+
+        owner = d.pop("owner")
+
+        short_description = d.pop("short_description")
+
+        _last_run = d.pop("last_run", UNSET)
+        last_run: Union[Unset, Run]
+        if isinstance(_last_run, Unset):
+            last_run = UNSET
+        else:
+            last_run = Run.from_dict(_last_run)
+
+        _next_run_at = d.pop("next_run_at")
+        next_run_at: Optional[datetime.datetime]
+        if _next_run_at is None:
+            next_run_at = None
+        else:
+            next_run_at = isoparse(_next_run_at)
+
+        schedule = d.pop("schedule")
+
+        status = d.pop("status", UNSET)
+
+        version = d.pop("version")
+
+        app = cls(
+            created_at=created_at,
+            name=name,
+            owner=owner,
+            short_description=short_description,
+            last_run=last_run,
+            next_run_at=next_run_at,
+            schedule=schedule,
+            status=status,
+            version=version,
+        )
+
+        return app

tower/tower_api_client/models/app_statistics.py

@@ -0,0 +1,66 @@
+from typing import Any, Dict, Type, TypeVar
+
+import attr
+
+T = TypeVar("T", bound="AppStatistics")
+
+
+@attr.s(auto_attribs=True)
+class AppStatistics:
+    """
+    Attributes:
+        all_apps (int):
+        disabled_apps (int):
+        exited_apps (int):
+        failed_apps (int):
+        running_apps (int):
+    """
+
+    all_apps: int
+    disabled_apps: int
+    exited_apps: int
+    failed_apps: int
+    running_apps: int
+
+    def to_dict(self) -> Dict[str, Any]:
+        all_apps = self.all_apps
+        disabled_apps = self.disabled_apps
+        exited_apps = self.exited_apps
+        failed_apps = self.failed_apps
+        running_apps = self.running_apps
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "all_apps": all_apps,
+                "disabled_apps": disabled_apps,
+                "exited_apps": exited_apps,
+                "failed_apps": failed_apps,
+                "running_apps": running_apps,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        all_apps = d.pop("all_apps")
+
+        disabled_apps = d.pop("disabled_apps")
+
+        exited_apps = d.pop("exited_apps")
+
+        failed_apps = d.pop("failed_apps")
+
+        running_apps = d.pop("running_apps")
+
+        app_statistics = cls(
+            all_apps=all_apps,
+            disabled_apps=disabled_apps,
+            exited_apps=exited_apps,
+            failed_apps=failed_apps,
+            running_apps=running_apps,
+        )
+
+        return app_statistics

tower/tower_api_client/models/app_summary.py

@@ -0,0 +1,81 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar
+
+import attr
+
+if TYPE_CHECKING:
+    from ..models.app import App
+    from ..models.run import Run
+    from ..models.run_results import RunResults
+
+
+T = TypeVar("T", bound="AppSummary")
+
+
+@attr.s(auto_attribs=True)
+class AppSummary:
+    """
+    Attributes:
+        app (App):
+        run_results (RunResults):
+        runs (List['Run']):
+        total_runs (int):
+    """
+
+    app: "App"
+    run_results: "RunResults"
+    runs: List["Run"]
+    total_runs: int
+
+    def to_dict(self) -> Dict[str, Any]:
+        app = self.app.to_dict()
+
+        run_results = self.run_results.to_dict()
+
+        runs = []
+        for runs_item_data in self.runs:
+            runs_item = runs_item_data.to_dict()
+
+            runs.append(runs_item)
+
+        total_runs = self.total_runs
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "app": app,
+                "run_results": run_results,
+                "runs": runs,
+                "total_runs": total_runs,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.app import App
+        from ..models.run import Run
+        from ..models.run_results import RunResults
+
+        d = src_dict.copy()
+        app = App.from_dict(d.pop("app"))
+
+        run_results = RunResults.from_dict(d.pop("run_results"))
+
+        runs = []
+        _runs = d.pop("runs")
+        for runs_item_data in _runs:
+            runs_item = Run.from_dict(runs_item_data)
+
+            runs.append(runs_item)
+
+        total_runs = d.pop("total_runs")
+
+        app_summary = cls(
+            app=app,
+            run_results=run_results,
+            runs=runs,
+            total_runs=total_runs,
+        )
+
+        return app_summary

tower/tower_api_client/models/app_version.py

@@ -0,0 +1,71 @@
+import datetime
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar
+
+import attr
+from dateutil.parser import isoparse
+
+if TYPE_CHECKING:
+    from ..models.parameter import Parameter
+
+
+T = TypeVar("T", bound="AppVersion")
+
+
+@attr.s(auto_attribs=True)
+class AppVersion:
+    """
+    Attributes:
+        created_at (datetime.datetime):
+        parameters (List['Parameter']):
+        version (str):
+    """
+
+    created_at: datetime.datetime
+    parameters: List["Parameter"]
+    version: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        created_at = self.created_at.isoformat()
+
+        parameters = []
+        for parameters_item_data in self.parameters:
+            parameters_item = parameters_item_data.to_dict()
+
+            parameters.append(parameters_item)
+
+        version = self.version
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "created_at": created_at,
+                "parameters": parameters,
+                "version": version,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.parameter import Parameter
+
+        d = src_dict.copy()
+        created_at = isoparse(d.pop("created_at"))
+
+        parameters = []
+        _parameters = d.pop("parameters")
+        for parameters_item_data in _parameters:
+            parameters_item = Parameter.from_dict(parameters_item_data)
+
+            parameters.append(parameters_item)
+
+        version = d.pop("version")
+
+        app_version = cls(
+            created_at=created_at,
+            parameters=parameters,
+            version=version,
+        )
+
+        return app_version

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

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