tower 0.3.4__py3-none-linux_armv6l.whl

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

tower/tower_api_client/models/create_account_params.py

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

tower/tower_api_client/models/create_account_params_flags_struct.py

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

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

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

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

tower/tower_api_client/models/create_app_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="CreateAppParams")
+
+
+@attr.s(auto_attribs=True)
+class CreateAppParams:
+    """
+    Attributes:
+        name (str): The name of the app.
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/CreateAppParams.json.
+        short_description (Union[Unset, str]): A description of the app.
+    """
+
+    name: str
+    schema: Union[Unset, str] = UNSET
+    short_description: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        name = self.name
+        schema = self.schema
+        short_description = self.short_description
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if schema is not UNSET:
+            field_dict["$schema"] = schema
+        if short_description is not UNSET:
+            field_dict["short_description"] = short_description
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        name = d.pop("name")
+
+        schema = d.pop("$schema", UNSET)
+
+        short_description = d.pop("short_description", UNSET)
+
+        create_app_params = cls(
+            name=name,
+            schema=schema,
+            short_description=short_description,
+        )
+
+        return create_app_params

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

tower/tower_api_client/models/create_device_login_ticket_response.py

@@ -0,0 +1,94 @@
+import datetime
+from typing import Any, Dict, Type, TypeVar, Union
+
+import attr
+from dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CreateDeviceLoginTicketResponse")
+
+
+@attr.s(auto_attribs=True)
+class CreateDeviceLoginTicketResponse:
+    """
+    Attributes:
+        device_code (str): The unique code identifying this device login request.
+        expires_in (int): Number of seconds until this request expires.
+        generated_at (datetime.datetime): When this device login request was created.
+        interval (int): Number of seconds to wait between polling attempts.
+        login_url (str): The URL where the user should go to enter the user code.
+        user_code (str): The code that the user needs to enter to authenticate.
+        verification_url (str): The URL that the device should poll to check authentication status.
+        schema (Union[Unset, str]): A URL to the JSON Schema for this object. Example:
+            http://localhost:8081/v1/schemas/CreateDeviceLoginTicketResponse.json.
+    """
+
+    device_code: str
+    expires_in: int
+    generated_at: datetime.datetime
+    interval: int
+    login_url: str
+    user_code: str
+    verification_url: str
+    schema: Union[Unset, str] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        device_code = self.device_code
+        expires_in = self.expires_in
+        generated_at = self.generated_at.isoformat()
+
+        interval = self.interval
+        login_url = self.login_url
+        user_code = self.user_code
+        verification_url = self.verification_url
+        schema = self.schema
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "device_code": device_code,
+                "expires_in": expires_in,
+                "generated_at": generated_at,
+                "interval": interval,
+                "login_url": login_url,
+                "user_code": user_code,
+                "verification_url": verification_url,
+            }
+        )
+        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()
+        device_code = d.pop("device_code")
+
+        expires_in = d.pop("expires_in")
+
+        generated_at = isoparse(d.pop("generated_at"))
+
+        interval = d.pop("interval")
+
+        login_url = d.pop("login_url")
+
+        user_code = d.pop("user_code")
+
+        verification_url = d.pop("verification_url")
+
+        schema = d.pop("$schema", UNSET)
+
+        create_device_login_ticket_response = cls(
+            device_code=device_code,
+            expires_in=expires_in,
+            generated_at=generated_at,
+            interval=interval,
+            login_url=login_url,
+            user_code=user_code,
+            verification_url=verification_url,
+            schema=schema,
+        )
+
+        return create_device_login_ticket_response

tower/tower_api_client/models/create_secret_params.py

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

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