tower 0.3.4__py3-none-linux_armv6l.whl

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

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

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

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

tower/tower_api_client/models/describe_secrets_key_response.py

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

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

tower/tower_api_client/models/error_detail.py

@@ -0,0 +1,54 @@
+from typing import Any, Dict, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ErrorDetail")
+
+
+@attr.s(auto_attribs=True)
+class ErrorDetail:
+    """
+    Attributes:
+        location (Union[Unset, str]): Where the error occurred, e.g. 'body.items[3].tags' or 'path.thing-id'
+        message (Union[Unset, str]): Error message text
+        value (Union[Unset, Any]): The value at the given location
+    """
+
+    location: Union[Unset, str] = UNSET
+    message: Union[Unset, str] = UNSET
+    value: Union[Unset, Any] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        location = self.location
+        message = self.message
+        value = self.value
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update({})
+        if location is not UNSET:
+            field_dict["location"] = location
+        if message is not UNSET:
+            field_dict["message"] = message
+        if value is not UNSET:
+            field_dict["value"] = value
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        location = d.pop("location", UNSET)
+
+        message = d.pop("message", UNSET)
+
+        value = d.pop("value", UNSET)
+
+        error_detail = cls(
+            location=location,
+            message=message,
+            value=value,
+        )
+
+        return error_detail

tower/tower_api_client/models/error_model.py

@@ -0,0 +1,109 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.error_detail import ErrorDetail
+
+
+T = TypeVar("T", bound="ErrorModel")
+
+
+@attr.s(auto_attribs=True)
+class ErrorModel:
+    """
+    Attributes:
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/ErrorModel.json.
+        detail (Union[Unset, str]): A human-readable explanation specific to this occurrence of the problem. Example:
+            Property foo is required but is missing..
+        errors (Union[Unset, List['ErrorDetail']]): Optional list of individual error details
+        instance (Union[Unset, str]): A URI reference that identifies the specific occurrence of the problem. Example:
+            https://example.com/error-log/abc123.
+        status (Union[Unset, int]): HTTP status code Example: 400.
+        title (Union[Unset, str]): A short, human-readable summary of the problem type. This value should not change
+            between occurrences of the error. Example: Bad Request.
+        type (Union[Unset, str]): A URI reference to human-readable documentation for the error. Default: 'about:blank'.
+            Example: https://example.com/errors/example.
+    """
+
+    schema: Union[Unset, str] = UNSET
+    detail: Union[Unset, str] = UNSET
+    errors: Union[Unset, List["ErrorDetail"]] = UNSET
+    instance: Union[Unset, str] = UNSET
+    status: Union[Unset, int] = UNSET
+    title: Union[Unset, str] = UNSET
+    type: Union[Unset, str] = "about:blank"
+
+    def to_dict(self) -> Dict[str, Any]:
+        schema = self.schema
+        detail = self.detail
+        errors: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.errors, Unset):
+            errors = []
+            for errors_item_data in self.errors:
+                errors_item = errors_item_data.to_dict()
+
+                errors.append(errors_item)
+
+        instance = self.instance
+        status = self.status
+        title = self.title
+        type = self.type
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update({})
+        if schema is not UNSET:
+            field_dict["$schema"] = schema
+        if detail is not UNSET:
+            field_dict["detail"] = detail
+        if errors is not UNSET:
+            field_dict["errors"] = errors
+        if instance is not UNSET:
+            field_dict["instance"] = instance
+        if status is not UNSET:
+            field_dict["status"] = status
+        if title is not UNSET:
+            field_dict["title"] = title
+        if type is not UNSET:
+            field_dict["type"] = type
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.error_detail import ErrorDetail
+
+        d = src_dict.copy()
+        schema = d.pop("$schema", UNSET)
+
+        detail = d.pop("detail", UNSET)
+
+        errors = []
+        _errors = d.pop("errors", UNSET)
+        for errors_item_data in _errors or []:
+            errors_item = ErrorDetail.from_dict(errors_item_data)
+
+            errors.append(errors_item)
+
+        instance = d.pop("instance", UNSET)
+
+        status = d.pop("status", UNSET)
+
+        title = d.pop("title", UNSET)
+
+        type = d.pop("type", UNSET)
+
+        error_model = cls(
+            schema=schema,
+            detail=detail,
+            errors=errors,
+            instance=instance,
+            status=status,
+            title=title,
+            type=type,
+        )
+
+        return error_model

tower/tower_api_client/models/export_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.exported_secret import ExportedSecret
+    from ..models.pagination import Pagination
+
+
+T = TypeVar("T", bound="ExportSecretsResponse")
+
+
+@attr.s(auto_attribs=True)
+class ExportSecretsResponse:
+    """
+    Attributes:
+        pages (Pagination):
+        secrets (List['ExportedSecret']):
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/ExportSecretsResponse.json.
+    """
+
+    pages: "Pagination"
+    secrets: List["ExportedSecret"]
+    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.exported_secret import ExportedSecret
+        from ..models.pagination import Pagination
+
+        d = src_dict.copy()
+        pages = Pagination.from_dict(d.pop("pages"))
+
+        secrets = []
+        _secrets = d.pop("secrets")
+        for secrets_item_data in _secrets:
+            secrets_item = ExportedSecret.from_dict(secrets_item_data)
+
+            secrets.append(secrets_item)
+
+        schema = d.pop("$schema", UNSET)
+
+        export_secrets_response = cls(
+            pages=pages,
+            secrets=secrets,
+            schema=schema,
+        )
+
+        return export_secrets_response

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

tower/tower_api_client/models/exported_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="ExportedSecret")
+
+
+@attr.s(auto_attribs=True)
+class ExportedSecret:
+    """
+    Attributes:
+        created_at (datetime.datetime):
+        encrypted_value (str):
+        environment (str):
+        name (str):
+    """
+
+    created_at: datetime.datetime
+    encrypted_value: str
+    environment: str
+    name: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        created_at = self.created_at.isoformat()
+
+        encrypted_value = self.encrypted_value
+        environment = self.environment
+        name = self.name
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "created_at": created_at,
+                "encrypted_value": encrypted_value,
+                "environment": environment,
+                "name": name,
+            }
+        )
+
+        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"))
+
+        encrypted_value = d.pop("encrypted_value")
+
+        environment = d.pop("environment")
+
+        name = d.pop("name")
+
+        exported_secret = cls(
+            created_at=created_at,
+            encrypted_value=encrypted_value,
+            environment=environment,
+            name=name,
+        )
+
+        return exported_secret